Merge branch 'port-e'

src/Document/CameraRawColor.cpp

@@ -79,25 +79,34 @@ bool CameraRawCurveSettings::adjusts() const
         || !isLinear(green) || !isLinear(blue);
 }
 
-double CameraRawCurveSettings::parametric(double tone) const
+// Bends tones below `lower` by `low`, above `upper` by `high`.
+double CameraRawCurveSettings::bend(double tone, double lower, double low, double upper, double high)
 {
-    const double shadow = shadowSplit / 100, dark = darkSplit / 100, light = lightSplit / 100;
-    double amount, lo, hi;
-    if (tone < shadow)
-        amount = shadows, lo = 0, hi = shadow;
-    else if (tone < dark)
-        amount = darks, lo = shadow, hi = dark;
-    else if (tone < light)
-        amount = lights, lo = dark, hi = light;
-    else
-        amount = highlights, lo = light, hi = 1;
-    const double span = std::max(0.02, hi - lo);
-    const double weight = 1 - std::abs(tone - (lo + hi) / 2) / (span / 2);
-    // A tone in its region weighs 0 to 1, unfloored.
-    return std::min(1.0, std::max(0.0, tone + (amount / 100) * weight * 0.22));
+    // Fitted to Photoshop: Darks −51 dips 0.1 there.
+    const double strength = 1.66;
+    if (tone < lower)
+        return lower * std::pow(tone / lower, std::pow(2, -low / 100 * strength));
+    if (tone > upper) {
+        const double rest = 1 - upper;
+        return 1 - rest * std::pow((1 - tone) / rest, std::pow(2, high / 100 * strength));
+    }
+    return tone;
 }
 
-std::vector<float> CameraRawCurveSettings::lumaTable() const
+double CameraRawCurveSettings::parametric(double tone) const
+{
+    if (shadows == 0 && darks == 0 && lights == 0 && highlights == 0)
+        return tone;
+    // Gamma bends, smoothed as Image › Curves smooths.
+    std::vector<CurvePoint> anchors;
+    for (int index = 0; index <= 32; ++index) {
+        const double x = index / 32.0;
+        anchors.push_back({x, bend(bend(x, shadowSplit / 100, shadows, lightSplit / 100, highlights), darkSplit / 100, darks, darkSplit / 100, lights)});
+    }
+    return point(tone, anchors);
+}
+
+std::vector<float> CameraRawCurveSettings::toneTable() const
 {
     std::vector<float> table(256);
     for (int index = 0; index < 256; ++index)
@@ -262,10 +271,10 @@ void CameraRawSettings::applyCurveColor(uchar *pixels, int width, int height, qs
     const CameraRawCurveSettings shape = curve.normalized();
     const CameraRawMixerSettings mixing = mixer.normalized();
     const CameraRawGradingSettings grade = grading.normalized();
-    const std::vector<float> luma = shape.lumaTable(), redTable = shape.channelTable(shape.red), greenTable = shape.channelTable(shape.green),
+    const std::vector<float> tone = shape.toneTable(), redTable = shape.channelTable(shape.red), greenTable = shape.channelTable(shape.green),
                              blueTable = shape.channelTable(shape.blue), mixerFloats = mixing.mixerFloats(), pointFloats = mixing.pointFloats(),
                              gradeFloats = grade.gradeFloats();
-    adjust_camera_raw_curve_color(pixels, size_t(width), size_t(height), size_t(stride), luma.data(), redTable.data(), greenTable.data(),
+    adjust_camera_raw_curve_color(pixels, size_t(width), size_t(height), size_t(stride), tone.data(), redTable.data(), greenTable.data(),
                                   blueTable.data(), shape.refineSaturation / 100, mixerFloats.data(), int(mixing.points.size()), pointFloats.data(),
                                   gradeFloats.data(), grade.blending / 100, grade.balance / 100, visualize);
 }

src/Document/CameraRawColor.h

@@ -33,15 +33,19 @@ struct CameraRawCurveSettings {
     static std::vector<CurvePoint> strongContrast();
     static bool isLinear(const std::vector<CurvePoint> &points);
     bool adjusts() const;
-    // Lifts or lowers the region a tone belongs to.
+    // Photoshop's parametric curve: gamma bends, smoothed as Curves.
     double parametric(double tone) const;
-    std::vector<float> lumaTable() const;
+    // Applied to red, green and blue alike.
+    std::vector<float> toneTable() const;
     std::vector<float> channelTable(const std::vector<CurvePoint> &points) const;
     CameraRawCurveSettings nudged(CameraRawPointChannel channel, double tone, double delta) const;
     // Swift's region(for:): the parametric amount a tone moves.
     double &region(double tone);
     CameraRawCurveSettings normalized() const;
     friend bool operator==(const CameraRawCurveSettings &, const CameraRawCurveSettings &) = default;
+
+private:
+    static double bend(double tone, double lower, double low, double upper, double high);
 };
 
 // One picked colour and how far its adjustment reaches.

src/Document/Dither.cpp

@@ -1,17 +1,28 @@
 #include "Document/Dither.h"
 #include "Document/BrushStroke.h"
+#include "Document/PixelAdjust.h"
 #include "IO/ImageExporter.h"
+#include "Rendering/PoolMap.h"
 #include <QFontMetricsF>
 #include <QPainter>
 #include <QPainterPath>
 #include <QTextBoundaryFinder>
 #include <algorithm>
 #include <cmath>
+#include <numeric>
 #include <set>
 extern "C" {
 #include "DitherPixels.h"
 }
 
+// The kernel's bands, where Swift's kernel calls dispatch_apply.
+extern "C" void dither_bands(size_t bands, void (*band)(void *context, size_t index), void *context)
+{
+    std::vector<size_t> indices(bands);
+    std::iota(indices.begin(), indices.end(), size_t(0));
+    PoolMap::blocking(indices, [band, context](size_t index) { band(context, index); });
+}
+
 // Swift's Dither.swift: the settings, the chunky pixels, the glyphs.
 namespace {
 // Swift's Characters: the text's graphemes.
@@ -53,6 +64,7 @@ QString rawValue(DitherStyle style)
     case DitherStyle::diamonds: return QStringLiteral("Halftone Diamonds");
     case DitherStyle::patterns: return QStringLiteral("Mac Patterns");
     case DitherStyle::ascii: return QStringLiteral("ASCII");
+    case DitherStyle::scanlines: return QStringLiteral("Scanlines (CRT)");
     }
     throw std::logic_error("unknown dither style");
 }
@@ -80,7 +92,12 @@ bool isHalftone(DitherStyle style)
 
 bool drawsMarks(DitherStyle style)
 {
-    return !hasTones(style);
+    return !hasTones(style) && style != DitherStyle::scanlines;
+}
+
+bool usesPixelSize(DitherStyle style)
+{
+    return style != DitherStyle::ascii && style != DitherStyle::scanlines;
 }
 
 QString rawValue(DitherPixelShape shape)
@@ -105,6 +122,10 @@ DitherSettings DitherSettings::normalized() const
     result.pixelSize = std::round(clamp(pixelSize, pixelSizeLow, pixelSizeHigh, 2));
     result.cellSize = std::round(clamp(cellSize, cellSizeLow, cellSizeHigh, 8));
     result.textSize = std::round(clamp(textSize, textSizeLow, textSizeHigh, 14));
+    result.lineSpacing = std::round(clamp(lineSpacing, lineSpacingLow, lineSpacingHigh, 4));
+    result.glow = clamp(glow, 0, 100, 35);
+    result.dots = clamp(dots, 0, 100, 0);
+    result.wobble = clamp(wobble, wobbleLow, wobbleHigh, 0);
     result.angle = clamp(angle, -90, 90, 45);
     result.levels = std::round(clamp(levels, levelsLow, levelsHigh, 2));
     result.diffusion = clamp(diffusion, 0, 100, 100);
@@ -125,8 +146,8 @@ DitherSettings DitherSettings::normalized() const
 QImage DitherSettings::apply(const QImage &image) const
 {
     const DitherSettings settings = normalized();
-    // ASCII draws at full resolution: chunks would blur its letters.
-    const int block = settings.style == DitherStyle::ascii ? 1 : int(settings.pixelSize);
+    // ASCII and Scanlines draw full size: chunks would blur them.
+    const int block = usesPixelSize(settings.style) ? int(settings.pixelSize) : 1;
     const QImage source = image.convertToFormat(QImage::Format_RGBA8888_Premultiplied);
     if (source.isNull())
         throw ExportError(ExportError::Kind::render);
@@ -153,6 +174,8 @@ QImage DitherSettings::apply(const QImage &image) const
         }
     }
     const QImage dithered = settings.dither(working);
+    if (settings.style == DitherStyle::scanlines && settings.glow > 0)
+        return settings.glowing(dithered);
     if (block <= 1)
         return dithered;
     // Blown back up without smoothing.
@@ -171,9 +194,42 @@ QImage DitherSettings::apply(const QImage &image) const
     return full;
 }
 
+// The lines' light blurred wide and added back: phosphor bloom.
+QImage DitherSettings::glowing(const QImage &image) const
+{
+    // Blurred small, scaled back up: same light, less work.
+    const double sigma = lineSpacing * 3 + 3, shrink = std::max(1.0, std::floor(sigma / 4));
+    const int width = image.width(), height = image.height();
+    // Swift clamps first: edges repeat outward before shrinking.
+    const int step = int(shrink), pad = int(std::ceil(sigma * 3 / shrink)) * step;
+    QImage padded = BrushRaster::context(width + 2 * pad, height + 2 * pad, false);
+    for (int y = 0; y < padded.height(); ++y) {
+        const uchar *source = image.constScanLine(std::clamp(y - pad, 0, height - 1));
+        uchar *out = padded.scanLine(y);
+        for (int x = 0; x < padded.width(); ++x)
+            std::copy_n(source + std::clamp(x - pad, 0, width - 1) * 4, 4, out + x * 4);
+    }
+    const int smallWidth = (padded.width() + step - 1) / step, smallHeight = (padded.height() + step - 1) / step;
+    const QImage small = padded.scaled(smallWidth, smallHeight, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+    if (small.isNull())
+        throw ExportError(ExportError::Kind::render);
+    const QImage blurred = PixelAdjust::gaussianBlur(small, sigma / shrink, true)
+                               .scaled(smallWidth * step, smallHeight * step, Qt::IgnoreAspectRatio, Qt::SmoothTransformation)
+                               .convertToFormat(QImage::Format_RGBA8888_Premultiplied);
+    QImage result = image.copy();
+    if (blurred.isNull() || result.isNull())
+        throw ExportError(ExportError::Kind::render);
+    // The scaled light's own rows, cropped to the image.
+    QImage bloom = BrushRaster::context(width, height, false);
+    for (int y = 0; y < height; ++y)
+        std::copy_n(blurred.constScanLine(y + pad) + pad * 4, width * 4, bloom.scanLine(y));
+    dither_glow(result.bits(), bloom.constBits(), size_t(width), size_t(height), size_t(result.bytesPerLine()), float(glow / 100 * 2.5));
+    return result;
+}
+
 QImage DitherSettings::dither(const QImage &image) const
 {
-    const int cell = int(cellSize);
+    const int cell = int(style == DitherStyle::scanlines ? lineSpacing : cellSize);
     const Glyphs glyphs = style == DitherStyle::ascii ? DitherSettings::glyphs(characters.isEmpty() ? defaultCharacters() : characters, int(textSize)) : Glyphs();
     const bool two = colors == DitherColors::twoColors;
     const std::array<uint8_t, 3> darkColor = two ? bytes(dark) : std::array<uint8_t, 3>{0, 0, 0};
@@ -184,7 +240,8 @@ QImage DitherSettings::dither(const QImage &image) const
                             .contrast = float(contrast / 100), .cell = cell, .angle = float(angle * M_PI / 180), .lightOnDark = lightOnDark ? 1 : 0,
                             .originalColors = colors == DitherColors::original ? 1 : 0, .dark = {darkColor[0], darkColor[1], darkColor[2]},
                             .light = {lightColor[0], lightColor[1], lightColor[2]}, .glyphWidth = glyphs.width, .glyphHeight = glyphs.height, .glyphs = glyphs.maps.data(),
-                            .glyphCoverage = glyphs.coverage.data(), .glyphCount = int(glyphs.coverage.size())};
+                            .glyphCoverage = glyphs.coverage.data(), .glyphCount = int(glyphs.coverage.size()), .dots = float(dots / 100),
+                            .wobble = float(wobble)};
         failed = dither_apply(pixels, size_t(width), size_t(height), size_t(stride), &params) == 0;
     });
     if (failed)

src/Document/Dither.h

@@ -6,10 +6,10 @@
 #include <vector>
 
 // Filter › Dither's looks, in the panel's order and DitherPixels.h's.
-enum class DitherStyle { atkinson, floydSteinberg, bayer2, bayer4, bayer8, dots, lines, diamonds, patterns, ascii };
-inline constexpr std::array allDitherStyles{DitherStyle::atkinson, DitherStyle::floydSteinberg, DitherStyle::bayer2, DitherStyle::bayer4,
-                                            DitherStyle::bayer8,   DitherStyle::dots,           DitherStyle::lines,  DitherStyle::diamonds,
-                                            DitherStyle::patterns, DitherStyle::ascii};
+enum class DitherStyle { atkinson, floydSteinberg, bayer2, bayer4, bayer8, dots, lines, diamonds, patterns, ascii, scanlines };
+inline constexpr std::array allDitherStyles{DitherStyle::atkinson, DitherStyle::floydSteinberg, DitherStyle::bayer2,   DitherStyle::bayer4,
+                                            DitherStyle::bayer8,   DitherStyle::dots,           DitherStyle::lines,    DitherStyle::diamonds,
+                                            DitherStyle::patterns, DitherStyle::ascii,          DitherStyle::scanlines};
 QString rawValue(DitherStyle style);
 // Swift's groups: diffusion, ordered, halftone, marks.
 int ditherGroup(DitherStyle style);
@@ -19,6 +19,8 @@ bool diffuses(DitherStyle style);
 bool hasTones(DitherStyle style);
 bool isHalftone(DitherStyle style);
 bool drawsMarks(DitherStyle style);
+// ASCII and Scanlines draw at full resolution, not chunky.
+bool usesPixelSize(DitherStyle style);
 
 // A chunky pixel: a square, or a dot on dark.
 enum class DitherPixelShape { square, dot };
@@ -35,6 +37,8 @@ struct DitherSettings {
     static constexpr double cellSizeLow = 4, cellSizeHigh = 64;
     static constexpr double textSizeLow = 6, textSizeHigh = 64;
     static constexpr double levelsLow = 2, levelsHigh = 8;
+    static constexpr double lineSpacingLow = 2, lineSpacingHigh = 32;
+    static constexpr double wobbleLow = 0, wobbleHigh = 64;
     static QString defaultCharacters() { return QStringLiteral(" .:-=+*#%@"); }
     DitherStyle style = DitherStyle::atkinson;
     // Each dithered pixel covers this many layer pixels a side.
@@ -44,6 +48,12 @@ struct DitherSettings {
     double cellSize = 8;
     // ASCII's line height in layer pixels; letters about 0.6 wide.
     double textSize = 14;
+    // Scanlines: the lines' distance apart, in layer pixels.
+    double lineSpacing = 4;
+    // Glow and dots 0–100%; wobble sideways in pixels.
+    double glow = 35;
+    double dots = 0;
+    double wobble = 0;
     // The halftone screen's angle, in degrees.
     double angle = 45;
     // Tones per channel; 2 is 1-bit.
@@ -76,4 +86,5 @@ struct DitherSettings {
 
 private:
     QImage dither(const QImage &image) const;
+    QImage glowing(const QImage &image) const;
 };

src/Document/ProjectWorkspace.cpp

@@ -235,14 +235,40 @@ bool ProjectWorkspace::finishTextEditing()
     return true;
 }
 
+void ProjectWorkspace::settlePendingEdits(std::function<void()> done)
+{
+    // Canvas edits are applied; dialogs cancelled, as their Cancel.
+    const std::shared_ptr<ProjectTab> settled = tab(current().id);
+    settled->session.commitGradient([self = QPointer<ProjectWorkspace>(this), settled, done] {
+        settled->session.finishPixelMove([self, settled, done] {
+            EditorSession &session = settled->session;
+            session.cancelFilter();
+            session.cancelHueSaturation();
+            session.cancelLevels();
+            session.cancelColorRange();
+            session.setSelectionAmountOperation(std::nullopt);
+            session.closeColorPicker(false);
+            if (self)
+                done();
+        });
+    });
+}
+
 void ProjectWorkspace::confirmQuit(std::function<void(bool)> done)
 {
-    if (!finishTextEditing() || !canSwitch()) {
+    if (m_isManaging || !finishTextEditing()) {
         finish(done, false);
         return;
     }
-    setManaging(true);
-    askNext(quitOrder(), 0, std::move(done));
+    settlePendingEdits([this, done] {
+        if (!canSwitch()) {
+            qCWarning(lcApp) << "Quit refused: the project is still busy";
+            finish(done, false);
+            return;
+        }
+        setManaging(true);
+        askNext(quitOrder(), 0, done);
+    });
 }
 
 void ProjectWorkspace::askNext(std::vector<std::shared_ptr<ProjectTab>> order, size_t index, std::function<void(bool)> done)

src/Document/ProjectWorkspace.h

@@ -44,6 +44,8 @@ public:
     void close(QUuid id, std::function<void()> done = {});
     void removeTab(QUuid id);
     std::vector<std::shared_ptr<ProjectTab>> quitOrder() const;
+    // Applies canvas edits and cancels dialogs before a quit.
+    void settlePendingEdits(std::function<void()> done);
     void confirmQuit(std::function<void(bool)> done);
     void closeWindow(QWidget *closing);
     void receive(const QList<QUrl> &urls, std::optional<QUuid> destination = std::nullopt,