Issue #118: First part of splitting

Pdf4QtLibCore/sources/pdfimageconversion.cpp

@@ -0,0 +1,190 @@
+#include "pdfimageconversion.h"
+
+#include <cmath>
+
+namespace pdf
+{
+
+PDFImageConversion::PDFImageConversion()
+{
+
+}
+
+void PDFImageConversion::setImage(QImage image)
+{
+    m_image = std::move(image);
+    m_convertedImage = QImage();
+    m_automaticThreshold = DEFAULT_THRESHOLD;
+}
+
+void PDFImageConversion::setConversionMethod(ConversionMethod method)
+{
+    m_conversionMethod = method;
+}
+
+void PDFImageConversion::setThreshold(int threshold)
+{
+    m_manualThreshold = threshold;
+}
+
+bool PDFImageConversion::convert()
+{
+    if (m_image.isNull())
+    {
+        return false;
+    }
+
+    QImage bitonal(m_image.width(), m_image.height(), QImage::Format_Mono);
+    bitonal.fill(0);
+
+    // Thresholding
+    int threshold = DEFAULT_THRESHOLD;
+
+    switch (m_conversionMethod)
+    {
+        case pdf::PDFImageConversion::ConversionMethod::Automatic:
+            m_automaticThreshold = calculateOtsu1DThreshold();
+            threshold = m_automaticThreshold;
+            break;
+
+        case pdf::PDFImageConversion::ConversionMethod::Manual:
+            threshold = m_manualThreshold;
+            break;
+
+        default:
+            Q_ASSERT(false);
+            break;
+    }
+
+    for (int y = 0; y < m_image.height(); ++y)
+    {
+        for (int x = 0; x < m_image.width(); ++x)
+        {
+            QColor pixelColor = m_image.pixelColor(x, y);
+            int pixelValue = pixelColor.lightness();
+            bool bit = (pixelValue >= threshold);
+            bitonal.setPixel(x, y, bit);
+        }
+    }
+
+    m_convertedImage = std::move(bitonal);
+    return true;
+}
+
+int PDFImageConversion::getThreshold() const
+{
+    switch (m_conversionMethod)
+    {
+        case pdf::PDFImageConversion::ConversionMethod::Automatic:
+            return m_automaticThreshold;
+
+        case pdf::PDFImageConversion::ConversionMethod::Manual:
+            return m_manualThreshold;
+
+        default:
+            Q_ASSERT(false);
+            break;
+    }
+
+    return DEFAULT_THRESHOLD;
+}
+
+QImage PDFImageConversion::getConvertedImage() const
+{
+    return m_convertedImage;
+}
+
+int PDFImageConversion::calculateOtsu1DThreshold() const
+{
+    if (m_image.isNull())
+    {
+        return 128;
+    }
+
+    // Histogram of lightness occurences
+    std::array<int, 256> histogram = { };
+
+    for (int x = 0; x < m_image.width(); ++x)
+    {
+        for (int y = 0; y < m_image.height(); ++y)
+        {
+            int lightness = m_image.pixelColor(x, y).lightness();
+            Q_ASSERT(lightness >= 0 && lightness <= 255);
+
+            int clampedLightness = qBound(0, lightness, 255);
+            histogram[clampedLightness] += 1;
+        }
+    }
+
+    float factor = 1.0f / float(m_image.width() * m_image.height());
+
+    std::array<float, 256> normalizedHistogram = { };
+    std::array<float, 256> cumulativeProbabilities = { };
+    std::array<float, 256> interClassVariance = { };
+
+    // Compute probabilities
+    for (size_t i = 0; i < histogram.size(); ++i)
+    {
+        normalizedHistogram[i] = histogram[i] * factor;
+        cumulativeProbabilities[i] = normalizedHistogram[i];
+
+        if (i > 0)
+        {
+            cumulativeProbabilities[i] += cumulativeProbabilities[i - 1];
+        }
+    }
+
+    // Calculate the inter-class variance for each threshold. Variables
+    // with the subscript 0 denote the background, while those with
+    // subscript 1 denote the foreground.
+    for (size_t i = 0; i < histogram.size(); ++i)
+    {
+        const float w0 = cumulativeProbabilities[i] - normalizedHistogram[i];
+        const float w1 = 1.0f - w0;
+
+        float u0 = 0.0f;
+        float u1 = 0.0f;
+
+        // Calculate mean intensity value of the background.
+        if (!qFuzzyIsNull(w0))
+        {
+            for (size_t j = 0; j < i; ++j)
+            {
+                u0 += j * normalizedHistogram[j];
+            }
+
+            u0 /= w0;
+        }
+
+        // Calculate mean intensity value of the foreground.
+        if (!qFuzzyIsNull(w1))
+        {
+            for (size_t j = i; j < histogram.size(); ++j)
+            {
+                u1 += j * normalizedHistogram[j];
+            }
+
+            u1 /= w1;
+        }
+
+        const float variance = w0 * w1 * std::pow(u0 - u1, 2);
+        interClassVariance[i] = variance;
+    }
+
+    // Find maximal value of the variance
+    size_t maxVarianceIndex = 0;
+    float maxVarianceValue = 0.0f;
+
+    for (size_t i = 0; i < interClassVariance.size(); ++i)
+    {
+        if (interClassVariance[i] > maxVarianceValue)
+        {
+            maxVarianceValue = interClassVariance[i];
+            maxVarianceIndex = i;
+        }
+    }
+
+    return int(maxVarianceIndex);
+}
+
+}   // namespace pdf