Bitmap Coloring layer version 2, with preview for scanned drawings

app/app.pro

@@ -59,6 +59,7 @@ INCLUDEPATH += \
 PRECOMPILED_HEADER = src/app-pch.h
 
 HEADERS += \
+    src/addtransparencytopaperdialog.h \
     src/app-pch.h \
     src/importlayersdialog.h \
     src/importpositiondialog.h \
@@ -102,7 +103,8 @@ HEADERS += \
     src/doubleprogressdialog.h \
     src/colorslider.h \
     src/checkupdatesdialog.h \
-    src/presetdialog.h     \
+    src/bitmapcoloring.h \
+    src/presetdialog.h \
     src/repositionframesdialog.h \
     src/commandlineparser.h \
     src/commandlineexporter.h \
@@ -111,6 +113,7 @@ HEADERS += \
     src/cameraoptionswidget.h
 
 SOURCES += \
+    src/addtransparencytopaperdialog.cpp \
     src/importlayersdialog.cpp \
     src/importpositiondialog.cpp \
     src/layeropacitydialog.cpp \
@@ -153,6 +156,7 @@ SOURCES += \
     src/doubleprogressdialog.cpp \
     src/colorslider.cpp \
     src/checkupdatesdialog.cpp \
+    src/bitmapcoloring.cpp \
     src/presetdialog.cpp \
     src/repositionframesdialog.cpp \
     src/app_util.cpp \
@@ -163,6 +167,7 @@ SOURCES += \
     src/cameraoptionswidget.cpp
 
 FORMS += \
+    ui/addtransparencytopaperdialog.ui \
     ui/cameraoptionswidget.ui \
     ui/camerapropertiesdialog.ui \
     ui/importimageseqpreview.ui \
@@ -191,6 +196,7 @@ FORMS += \
     ui/filespage.ui \
     ui/toolspage.ui \
     ui/toolboxwidget.ui \
+    ui/bitmapcoloringwidget.ui \
     ui/presetdialog.ui
 
 GIT {

app/data/app.qrc

@@ -54,6 +54,9 @@
         <file>icons/new/svg/smudge_detailed.svg</file>
         <file>icons/new/svg/trash_detailed.svg</file>
         <file>icons/new/checkerboard_smaller.png</file>
+        <file>icons/blue.png</file>
+        <file>icons/green.png</file>
+        <file>icons/red.png</file>
         <file>icons/overlayCenter.png</file>
         <file>icons/overlayGoldenRatio.png</file>
         <file>icons/overlaySafe.png</file>

app/src/addtransparencytopaperdialog.cpp

@@ -0,0 +1,250 @@
+#include "addtransparencytopaperdialog.h"
+#include "ui_addtransparencytopaperdialog.h"
+
+#include <QGraphicsPixmapItem>
+#include <QProgressDialog>
+#include <QDebug>
+
+#include "editor.h"
+#include "layermanager.h"
+#include "selectionmanager.h"
+#include "layerbitmap.h"
+#include "bitmapimage.h"
+
+
+AddTransparencyToPaperDialog::AddTransparencyToPaperDialog(QDialog *parent) :
+    QDialog(parent),
+    ui(new Ui::AddTransparencyToPaperDialog)
+{
+    ui->setupUi(this);
+    ui->mainLayout->setStretchFactor(ui->optionsLayout, 1);
+    ui->mainLayout->setStretchFactor(ui->previewLayout, 20);
+
+    connect(this, &QDialog::finished, this, &AddTransparencyToPaperDialog::closeDialog);
+    connect(ui->sb_treshold, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &AddTransparencyToPaperDialog::SpinboxChanged);
+    connect(ui->sliderThreshold, &QSlider::valueChanged, this, &AddTransparencyToPaperDialog::SliderChanged);
+    connect(ui->cb_Red, &QCheckBox::stateChanged, this, &AddTransparencyToPaperDialog::updateDrawing);
+    connect(ui->cb_Green, &QCheckBox::stateChanged, this, &AddTransparencyToPaperDialog::updateDrawing);
+    connect(ui->cb_Blue, &QCheckBox::stateChanged, this, &AddTransparencyToPaperDialog::updateDrawing);
+    connect(ui->btnCancel, &QPushButton::clicked, this, &AddTransparencyToPaperDialog::closeDialog);
+    connect(ui->btnApply, &QPushButton::clicked, this, &AddTransparencyToPaperDialog::traceScannedDrawings);
+    connect(ui->testTransparencyCheckbox, &QCheckBox::stateChanged, this, &AddTransparencyToPaperDialog::checkerStateChanged);
+    connect(ui->zoomSlider, &QSlider::valueChanged, this, &AddTransparencyToPaperDialog::zoomChanged);
+}
+
+AddTransparencyToPaperDialog::~AddTransparencyToPaperDialog()
+{
+    delete ui;
+}
+
+void AddTransparencyToPaperDialog::setCore(Editor *editor)
+{
+    mEditor = editor;
+}
+
+void AddTransparencyToPaperDialog::initUI()
+{
+    if (mEditor->layers()->currentLayer()->type() != Layer::BITMAP)
+        this->setEnabled(false);
+    loadDrawing(mEditor->currentFrame());
+    connect(mEditor->layers(), &LayerManager::currentLayerChanged, this, &AddTransparencyToPaperDialog::layerChanged);
+    connect(mEditor, &Editor::scrubbedTo, this, &AddTransparencyToPaperDialog::updateDrawing);
+    connect(mEditor, &Editor::currentFrameUpdated, this, &AddTransparencyToPaperDialog::updateDrawing);
+
+    scene.setBackgroundBrush(Qt::white);
+    ui->preview->setScene(&scene);
+    ui->preview->show();
+
+    if (!mBitmap.bounds().isValid()) {
+        ui->btnApply->setEnabled(false);
+    }
+}
+
+void AddTransparencyToPaperDialog::SpinboxChanged(int value)
+{
+    mThreshold = value;
+    ui->sliderThreshold->setValue(value);
+    updateDrawing();
+}
+
+void AddTransparencyToPaperDialog::SliderChanged(int value)
+{
+    mThreshold = value;
+    ui->sb_treshold->setValue(value);
+    updateDrawing();
+}
+
+void AddTransparencyToPaperDialog::checkerStateChanged(bool state)
+{
+    if (state) {
+        scene.setBackgroundBrush(QBrush(QImage(":/background/checkerboard.png")));
+    } else {
+        scene.setBackgroundBrush(Qt::white);
+    }
+}
+
+void AddTransparencyToPaperDialog::zoomChanged(int zoomLevel)
+{
+    mZoomLevel = zoomLevel;
+    updatePreview();
+}
+
+void AddTransparencyToPaperDialog::resizeEvent(QResizeEvent*)
+{
+    updatePreview();
+}
+
+void AddTransparencyToPaperDialog::updatePreview()
+{
+    QImage loadedImage = *mBitmap.image();
+
+    QSize previewSize = ui->preview->size()*mZoomLevel;
+    QSize size = mBitmap.size().scaled(previewSize, Qt::KeepAspectRatioByExpanding);
+    mPixmapFromImage = QPixmap(size);
+    mPixmapFromImage.fill(Qt::transparent);
+
+    QPainter painter(&mPixmapFromImage);
+
+    painter.drawImage(QRect(QPoint(0,0),QSize(size)), loadedImage, loadedImage.rect());
+    mPreviewImageItem->setPixmap(mPixmapFromImage);
+
+    scene.setSceneRect(QRect(QPoint(), previewSize));
+}
+
+void AddTransparencyToPaperDialog::loadDrawing(int frame)
+{
+    if (mEditor->layers()->currentLayer()->type() != Layer::BITMAP) { return; }
+
+    LayerBitmap* layer = static_cast<LayerBitmap*>(mEditor->layers()->currentLayer());
+
+    if (!layer->keyExists(frame))
+    {
+        if (!layer->keyExistsWhichCovers(frame))
+            frame = layer->getPreviousKeyFramePosition(frame);
+        else
+            frame = layer->getNextKeyFramePosition(frame);
+    }
+
+    ui->labShowingFrame->setText(tr("Previewing frame %1").arg(QString::number(frame)));
+
+    BitmapImage* currentImage = layer->getBitmapImageAtFrame(frame);
+
+    if (!currentImage) { return; }
+
+    mBitmap = currentImage->copy();
+    mBitmap.setThreshold(mThreshold);
+
+    mBitmap = *mBitmap.scanToTransparent(&mBitmap,
+                                         ui->cb_Red->isChecked(),
+                                         ui->cb_Green->isChecked(),
+                                         ui->cb_Blue->isChecked());
+
+    if (mPreviewImageItem == nullptr) {
+        mPreviewImageItem = scene.addPixmap(mPixmapFromImage);
+    } else {
+        mPreviewImageItem->setPixmap(mPixmapFromImage);
+    }
+
+    ui->btnApply->setEnabled(true);
+
+    updatePreview();
+}
+
+void AddTransparencyToPaperDialog::updateDrawing()
+{
+    loadDrawing(mEditor->currentFrame());
+}
+
+void AddTransparencyToPaperDialog::layerChanged(int index)
+{
+    if (mEditor->layers()->getLayer(index)->type() == Layer::BITMAP)
+    {
+        this->setEnabled(true);
+        updateDrawing();
+    }
+    else
+    {
+        this->setEnabled(false);
+    }
+}
+
+void AddTransparencyToPaperDialog::traceScannedDrawings()
+{
+    if (mEditor->layers()->currentLayer()->type() != Layer::BITMAP) { return; }
+
+    LayerBitmap* layer = static_cast<LayerBitmap*>(mEditor->layers()->currentLayer());
+    BitmapImage* img = new BitmapImage();
+    bool somethingSelected = mEditor->select()->somethingSelected();
+
+    if (ui->rbCurrentKeyframe->isChecked())
+    {
+        int frame = mEditor->currentFrame();
+        if (!layer->keyExists(frame))
+        {
+            if (!layer->keyExistsWhichCovers(frame))
+                frame = layer->getPreviousKeyFramePosition(frame);
+            else
+                frame = layer->getNextKeyFramePosition(frame);
+        }
+        mEditor->scrubTo(frame);
+
+        if (somethingSelected)
+        {
+            mEditor->copy();
+            layer->removeKeyFrame(frame);
+            layer->addNewKeyFrameAt(frame);
+            mEditor->paste();
+        }
+        img = layer->getBitmapImageAtFrame(frame);
+        img->setThreshold(mThreshold);
+        img = img->scanToTransparent(img,
+                                     ui->cb_Red->isChecked(),
+                                     ui->cb_Green->isChecked(),
+                                     ui->cb_Blue->isChecked());
+        img->modification();
+    }
+    else
+    {
+        mEditor->setIsDoingRepeatColoring(true);
+        int count = mEditor->getAutoSaveCounter();
+        QProgressDialog* mProgress = new QProgressDialog(tr("Tracing scanned drawings..."), tr("Abort"), 0, 100, this);
+        mProgress->setWindowModality(Qt::WindowModal);
+        mProgress->show();
+        mProgress->setMaximum(layer->keyFrameCount());
+        mProgress->setValue(0);
+        int keysThinned = 0;
+        QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
+        for (int i = layer->firstKeyFramePosition(); i <= layer->getMaxKeyFramePosition(); i++)
+        {
+            if (layer->keyExists(i))
+            {
+                mProgress->setValue(keysThinned++);
+                mEditor->scrubTo(i);
+                count++;
+                if (mProgress->wasCanceled())
+                {
+                    break;
+                }
+                if (somethingSelected)
+                {
+                    mEditor->copy();
+                    layer->removeKeyFrame(i);
+                    layer->addNewKeyFrameAt(i);
+                    mEditor->paste();
+                }
+                img = layer->getBitmapImageAtFrame(i);
+                img->setThreshold(mThreshold);
+                img = img->scanToTransparent(img,
+                                             ui->cb_Red->isChecked(),
+                                             ui->cb_Green->isChecked(),
+                                             ui->cb_Blue->isChecked());
+                img->modification();
+            }
+        }
+        mProgress->close();
+        mEditor->setIsDoingRepeatColoring(false);
+        mEditor->setAutoSaveCounter(count);
+    }
+    if (ui->rbAllKeyframes->isChecked())
+        emit closeDialog();
+}

app/src/addtransparencytopaperdialog.h

@@ -0,0 +1,60 @@
+#ifndef ADDTRANSPARENCYTOPAPERDIALOG_H
+#define ADDTRANSPARENCYTOPAPERDIALOG_H
+
+#include <QDialog>
+#include <QGraphicsScene>
+
+#include "bitmapimage.h"
+
+class Editor;
+class QGraphicsPixmapItem;
+
+namespace Ui {
+class AddTransparencyToPaperDialog;
+}
+
+class AddTransparencyToPaperDialog : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit AddTransparencyToPaperDialog(QDialog *parent = nullptr);
+    ~AddTransparencyToPaperDialog() override;
+
+    void setCore(Editor* editor);
+
+    void initUI();
+
+signals:
+    void closeDialog();
+
+protected:
+    void resizeEvent(QResizeEvent*) override;
+
+private slots:
+    void SpinboxChanged(int value);
+    void SliderChanged(int value);
+    void traceScannedDrawings();
+    void updateDrawing();
+    void layerChanged(int index);
+    void checkerStateChanged(bool state);
+    void zoomChanged(int zoomLevel);
+
+private:
+    void updatePreview();
+    void loadDrawing(int frame);
+
+    int mZoomLevel = 1;
+
+    Ui::AddTransparencyToPaperDialog *ui;
+
+    QGraphicsScene scene;
+    QGraphicsPixmapItem* mPreviewImageItem = nullptr;
+
+    int mThreshold = 220;
+    BitmapImage mBitmap;
+    QPixmap mPixmapFromImage;
+    Editor* mEditor = nullptr;
+};
+
+#endif // ADDTRANSPARENCYTOPAPERDIALOG_H