scanned-image-extractor/scannerExtract/extracttargets.cpp

286 lines
9.0 KiB
C++
Raw Normal View History

2024-01-29 23:24:37 +00:00
/***********************************************************************
* This file is part of Scanned Image Extract.
*
* Scanned Image Extract is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Scanned Image Extract 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scanned Image Extract. If not, see <http://www.gnu.org/licenses/>
*
*
* Copyright (C) 2015, Dominik Rueß; info@dominik-ruess.de
**********************************************************************/
#include <QtCore/qmath.h>
#include "extracttargets.h"
QMutex ExtractTargets::imageMutex;
QMutex ExtractTargets::fileListMutex;
ExtractTargets::ExtractTargets(QObject *parent)
: QThread(parent)
, _stopped(false)
, _abortCurrentStartNext(false)
{
}
void ExtractTargets::addTarget(TargetImagePtr target,
SourceFilePtr source,
const bool highPriority)
{
QMutexLocker l(&fileListMutex);
if (_current.get() != 0
&& _current->workOnId == target->workOnId)
{
// already loading -> do nothing
return;
}
if (highPriority) {
_abortCurrentStartNext = true;
}
QPair<TargetImagePtr, SourceFilePtr> item(target, source);
if (highPriority) {
_targetList.push_front(item);
}
else {
_targetList.push_back(item);
}
// find duplicates and delete (work from back)
for (int i=_targetList.size()-1; i>=0; i--) {
for (int j=i-1; j>=0; j--) {
if (_targetList[i].first->workOnId
== _targetList[j].first->workOnId) {
_targetList.erase(_targetList.begin() + i);
}
}
}
_stopped = false;
if (!isRunning()) {
start(QThread::HighPriority);
} else {
_condition.wakeOne();
}
}
void ExtractTargets::stop()
{
_stopped = true;
}
ExtractTargets::~ExtractTargets()
{
fileListMutex.lock();
_targetList.clear();
_stopped = true;
_condition.wakeAll();
fileListMutex.unlock();
wait();
}
void ExtractTargets::run()
{
while (!_stopped) {
_abortCurrentStartNext = false;
{
QMutexLocker l(&fileListMutex);
if (_targetList.size() == 0) {
_condition.wait(&fileListMutex);
// continue: in the meantime it might have been stopped
// or set empty
continue;
}
}
fileListMutex.lock();
_current = _targetList.first().first;
SourceFilePtr currentSource = _targetList.first().second;
fileListMutex.unlock();
imageMutex.lock();
extract(_current, currentSource);
imageMutex.unlock();
if (_stopped || _abortCurrentStartNext) {
continue;
}
fileListMutex.lock();
_targetList.pop_front();
fileListMutex.unlock();
if (!_stopped) {
emit doneTarget(_current);
}
_current = TargetImagePtr();
}
}
void ExtractTargets::extract(TargetImagePtr target, SourceFilePtr source)
{
QImage out;
if (source->imageOrig.isNull()
|| source->imageOrig.width() == 0
|| source->imageOrig.height() == 0)
{
target->backmap = BackMapPtr();
target->image = QImage();
return;
}
const QImage& sourceImage = source->imageOrig;
const double cropPerc = target->boundary->getCrop() < 0 ? _cropPercentage : target->boundary->getCrop();
target->boundary->setCrop(cropPerc);
const int width = _norm(target->boundary->corners()[0] * (1-cropPerc)
-target->boundary->corners()[3] * (1-cropPerc));
const int height = _norm(target->boundary->corners()[1] * (1-cropPerc)
-target->boundary->corners()[0] * (1-cropPerc));
out = QImage(width, height, QImage::Format_RGB32);
out.fill(QColor(0,0,0));
// check correct order, such that it does not reflect in any dimension
// (no flipping)
double anglesSource[4];
QPointF center(0,0);
for (int i=0;i<4;i++) {
center += target->boundary->corners()[0];
}
center /= 4;
center = target->boundary->mapToScene(center);
for (int i=0; i<4; i++) {
QPointF curr = target->boundary->mapToScene(target->boundary->corners()[i])-center;
anglesSource[i] = qAtan2(curr.y(), curr.x());
}
int numNeg = 0;
for (int i=0; i<4; i++) {
const double sgn1 = (anglesSource[i]-anglesSource[(i+3)%4]);
//const double sgn2 = (anglesTarget[i]-anglesTarget[(i+3)%4]);
if (sgn1 < 0) numNeg++;
}
// either double reflected (numNeg == 2) or only one side
if (numNeg >= 2) {
QPointF corners[4];
if (numNeg > 2) {
corners[0] = target->boundary->corners()[0];
corners[1] = target->boundary->corners()[3];
corners[2] = target->boundary->corners()[2];
corners[3] = target->boundary->corners()[1];
} else {
corners[0] = target->boundary->corners()[2];
corners[1] = target->boundary->corners()[3];
corners[2] = target->boundary->corners()[0];
corners[3] = target->boundary->corners()[1];
}
target->boundary->setCorners(corners);
// start over again
extract(target, source);
}
else
{
// now also check the orientation, it has to be
// similar to the source. meaning roughly upright -> upright
QPointF currRot = target->boundary->mapToScene(target->boundary->corners()[2])
-target->boundary->mapToScene(target->boundary->corners()[1]);
const double resultAngle = qAtan2( currRot.y(),
currRot.x() );
const int num90DegreeBins = qRound((resultAngle)/(M_PI/2.0));
QPointF dirX(target->boundary->corners()[3]* (1-cropPerc)
-target->boundary->corners()[0]* (1-cropPerc)),
dirY(target->boundary->corners()[0]* (1-cropPerc)
-target->boundary->corners()[1]* (1-cropPerc));
QSizeF size(_norm(dirX), _norm(dirY)) ;
dirX /= size.width();
dirY /= size.height();
QPointF center(0.5*(target->boundary->mapToScene(target->boundary->corners()[0])
+ target->boundary->mapToScene(target->boundary->corners()[2])));
const int sourceHeight = sourceImage.height();
const int sourceWidth = sourceImage.width();
target->backmap = BackMapPtr(new BackMap(resultAngle,
center,
size,
source->scale));
#pragma omp parallel for
for (int y=0; y<height; y++) {
if (!_stopped && !_abortCurrentStartNext)
{
for (int x=0; x<width; x++) {
//QPointF pos(y -height/2.0, x -width/2.0);
QPointF pos(target->boundary->corners()[1]* (1-cropPerc)
+ y*dirY + x*dirX);
pos = target->boundary->mapToScene(pos);
const int xSource = qRound(pos.x());
const int ySource = qRound(pos.y());
if (xSource >= 0
&& xSource < sourceWidth
&& ySource >= 0
&& ySource < sourceHeight) {
out.setPixel(x,y, sourceImage.pixel(xSource, ySource));
} else {
out.setPixel(x,y,qRgb(0,0,0));
}
}
}
}
if (_stopped || _abortCurrentStartNext) {
target->width = 0;
target->height = 0;
target->backmap = BackMapPtr();
target->image = QImage();
return;
}
else
{
target->width = (double)width * source->scale;
target->height = (double)height * source->scale;
}
// finally, add normalizing rotation and user rotation:
out = out.transformed(QTransform().rotate( num90DegreeBins*90).rotate(target->rotation*90));
target->determinedRotation = num90DegreeBins;
target->image = out;
}
}
inline double ExtractTargets::_norm(const QPointF& p)
{
return qSqrt(p.x()*p.x() + p.y()*p.y());
}
inline double ExtractTargets::_dot(const QPointF& p1, const QPointF& p2)
{
return p1.x() * p2.x() + p1.y() * p2.y();
}
inline double ExtractTargets::_norm2(const QPointF& p)
{
return p.x()*p.x() + p.y()*p.y();
}