scanned-image-extractor/module_misc/filenamenumbering_pre.cpp
2024-01-30 00:24:37 +01:00

452 lines
16 KiB
C++

/***********************************************************************
* This file is part of module_misc.
*
* module_misc 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.
*
* module_misc 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 module_misc. If not, see <http://www.gnu.org/licenses/>
*
*
* Copyright (C) 2015, Dominik Rueß; info@dominik-ruess.de
**********************************************************************/
#include <QFileInfo>
#include <QDebug>
#include <QMultiMap>
#include <QVector>
#include <QPair>
#include "filenamenumbering_pre.h"
namespace MiscTools
{
/**
* a separator to build up a filenamestring
*/
#ifdef _WIN32
#define SEPARATOR QString("<")
#else
#define SEPARATOR QString('/')
#endif
FilenameNumbering_PRE::FilenameNumbering_PRE()
{
}
InfoList FilenameNumbering_PRE::splitFileToStringParts(const QString& filenameOrig,
const bool caseInsensitive,
const bool withoutExtension,
InfoList *stringValues)
{
InfoList out;
if (stringValues != NULL) {
stringValues->clear();
}
const QFileInfo f = filenameOrig;
QString filename;
if (withoutExtension) {
filename = caseInsensitive ? f.completeBaseName().toLower() : f.completeBaseName();
} else {
filename = caseInsensitive ? f.fileName().toLower() : f.fileName();
}
for (int i=0; i<filename.length(); i++) {
// add the case that a negative number is present,
// hence if a negative sign is followed by a digit
bool negativeSignTest = (filename[i]=='-'
&& i < filename.length()-1
&& filename[i+1].isDigit()
&& (i==0 || filename[i-1] == QChar(' ')) );
if (filename[i].isDigit() || negativeSignTest) {
QString num;
while ((filename[i].isDigit() || negativeSignTest)&& i<filename.length()) {
num += filename[i];
i++;
negativeSignTest=false;//only allowed at first char
}
i--;
out << num.toInt();
if (stringValues != NULL) {
(*stringValues) << num;
}
} else {
QString part = "";
while (!negativeSignTest && !filename[i].isDigit() && i<filename.length()) {
part += filename[i];
i++;
// if a minus character occurs with a following digit, then this is part of a number
negativeSignTest = (filename[i]=='-' && i < filename.length()-1 && filename[i+1].isDigit());
}
i--;
out << part;
if (stringValues != NULL) {
(*stringValues) <<part;
}
}
}
return out;
}
QVector<InfoList> FilenameNumbering_PRE::getDifferentFile_Patterns(QStringList filenames,
const bool caseInsensitive,
const bool withoutExtension)
{
QVector<InfoList> patterns;
for (int i=0; i<filenames.size(); i++) {
const InfoList fileParts = splitFileToStringParts(filenames[i],
caseInsensitive,
withoutExtension);
if (!patterns.contains(fileParts)) {
patterns.push_back(fileParts);
}
}
return patterns;
}
void FilenameNumbering_PRE::getUniqueNumbersAndValues(const QStringList filenames,
const bool diffSuffixSameNumbers,
QVector<QVector<int> > &fileNumberValues,
QVector<bool> &numbersUnique,
QVector<int> &numberingPositions,
bool & onePatternFound,
const bool caseInsensitive,
const bool withoutExtension)
{
const int nF = filenames.size();
fileNumberValues.clear();
numbersUnique.clear();
numberingPositions.clear();
const QVector<InfoList> diffPatterns = getDifferentFile_Patterns(filenames, caseInsensitive, withoutExtension);
if (diffPatterns.size() != 1) {
onePatternFound = false;
qWarning() << "different file patterns found, please revise";
return;
}
onePatternFound = true;
const InfoList patterns = diffPatterns.first();
numberingPositions.clear();
for (int i=0; i<patterns.size(); i++) {
if (patterns[i].typeName() == QString("int")) {
numberingPositions.push_back(i);
}
}
const int n = numberingPositions.size();
if (n == 0) {
qWarning() << "no numbers found";
return;
}
fileNumberValues.resize(n);
numbersUnique.resize(n);
for (int numPos=0; numPos<n; numPos++) {
fileNumberValues[numPos].resize(nF);
for (int j=0; j<nF; j++) {
InfoList f = splitFileToStringParts(filenames[j], caseInsensitive, withoutExtension);
fileNumberValues[numPos][j] = f.at(numberingPositions[numPos]).toInt();
}
// unique test
bool unique = true;
QMultiMap<int, int> tmp;
for (int i=0; i<nF; i++) {
tmp.insertMulti(fileNumberValues[numPos][i], i);
}
QList<int> sortedInd = tmp.values();
for (int j=0; j<nF; j++) {
int k = j+1;
while(k < nF && fileNumberValues[numPos][sortedInd[j]] ==
fileNumberValues[numPos][sortedInd[k]])
{
if (fileNumberValues[numPos][sortedInd[k]] ==
fileNumberValues[numPos][sortedInd[j]]){
if (diffSuffixSameNumbers) {
const QFileInfo f1 = filenames[sortedInd[k]];
const QFileInfo f2 = filenames[sortedInd[j]];
if ( (caseInsensitive && f1.suffix().toLower() == f2.suffix().toLower() )
|| (!caseInsensitive && f1.suffix() == f2.suffix() ) ){
unique = false;
break;
}
} else {
unique = false;
break;
}
}
k++;
}
if (!unique) {
break;
}
}
numbersUnique[numPos] = unique;
}
}
bool FilenameNumbering_PRE::getTagsBackMapAndNumbers(
const QStringList& filenames,
const QString& taggedFileName,
const QVector<QPair<QString, QString> >& tagsAndDateMap,
const QString& tag,
QVector<int >& runningFileNumbers,
QVector<QVector<QPair<int, int> > >& startAndLengthOfRunnNumbers)
{
startAndLengthOfRunnNumbers.clear();
runningFileNumbers.clear();
QMultiMap<int, int> tagPositions;
QVector<QVector<QVariant> > filenameNumericValues;
QVector<int> tmp1;
QString tmp2;
QVector<QVector<QPair<int, int> > > startAndLengthOfAllTags;
_getTagMap(filenames,
taggedFileName,
tagsAndDateMap,
tagPositions,
tmp1, tmp2,
filenameNumericValues,
startAndLengthOfAllTags);
if (filenameNumericValues.size() != filenames.size()) {
qWarning() << "number of filenames mismatch";
return false;
}
// create tag number map to numerical value
// position in filename,
QVector<int> numberingPos;
QMapIterator<int, int> i(tagPositions);
int k=0;
while (i.hasNext()) {
i.next();
const int tagNo = i.value();
if (tagsAndDateMap[tagNo].first == tag) {
numberingPos.push_back(k);
}
k++;
}
if (numberingPos.size() == 0) {
qWarning() << "could not determine running number";
return false;
}
const int n = filenames.size();
runningFileNumbers.resize(n);
startAndLengthOfRunnNumbers.resize(n);
for (int j=0; j<n; j++) {
if (filenameNumericValues[j].size() == 0) {
qWarning() << "no running number detected for " << filenames.at(j);
runningFileNumbers[j] = -1;
continue;
}
//startAndLengthOfRunnNumbers[j].resize(k);
for (int k=0; k<numberingPos.size(); k++) {
if (filenameNumericValues[j][numberingPos[k]].type() != QVariant::Int) {
qWarning() << "tried to convert a string to a running number, return false";
return false;
}
if (k==0) {
runningFileNumbers[j] = filenameNumericValues[j][numberingPos[k]].toInt();
} else if (filenameNumericValues[j][numberingPos[k]].toInt() != runningFileNumbers[j]){
qWarning() << "warning, inconsistent running numbers for "
<< filenames.at(j);
}
startAndLengthOfRunnNumbers[j].push_back(startAndLengthOfAllTags[j][numberingPos[k]]);
}
}
return true;
}
bool FilenameNumbering_PRE::_getTagMap(
const QStringList& filenames,
const QString& taggedFileName,
const QVector<QPair<QString, QString> >& tagsAndDateMap,
QMultiMap<int, int>& tagPositions, // first = tagNo, second = tagOrderPos;
QVector<int>& datePatternsUsed,
QString& datePattern,
QVector<QVector<QVariant> >& filenameNumericValues,
QVector<QVector<QPair<int, int> > >& tagSourceFNPositionsAndLengths)
{
// find positions and order of given tags
datePattern="";
tagPositions.clear();
datePatternsUsed.clear();
filenameNumericValues.clear();
tagSourceFNPositionsAndLengths.clear();
for (int i=0;i<tagsAndDateMap.size(); i++) {
int pos = taggedFileName.indexOf(tagsAndDateMap[i].first);
while (pos >=0) {
tagPositions.insertMulti(pos, i);
pos = taggedFileName.indexOf(tagsAndDateMap[i].first, pos+1);
}
}
// now extract fixed text between tags
// also create datePatterns/parse format for comparison
QStringList textInBetween;
datePattern = "";
datePatternsUsed.clear();
QMapIterator<int, int> i(tagPositions);
int pos = 0;
int k=0;
while (i.hasNext()) {
i.next();
const int tagPos = i.key();
const int tagNo = i.value();
if (tagsAndDateMap[tagNo].second.length() > 0) {
datePatternsUsed.push_back(k);
datePattern += QString("%1%2").arg(SEPARATOR).arg(tagsAndDateMap[tagNo].second);
}
if (tagPos != pos) {
textInBetween.push_back(taggedFileName.mid(pos, tagPos-pos));
}
pos = tagPos + tagsAndDateMap[tagNo].first.length();
k++;
if (!i.hasNext()) {
if (pos != taggedFileName.length()) {
textInBetween.push_back(taggedFileName.right(taggedFileName.length()-pos));
}
}
}
// strip all known text to obtain numerical values
const int n = filenames.size();
const int d = tagPositions.size();
filenameNumericValues.resize(n);
tagSourceFNPositionsAndLengths.resize(n);
for (int i=0; i<n; i++) {
filenameNumericValues[i].resize(d);
tagSourceFNPositionsAndLengths[i].resize(d);
QString fn = QFileInfo(filenames[i]).baseName();
const int originalFilenameLength = fn.length();
// first of all replace all fixed text with spaces
int pos = 0;
int currPosValue = 0;
int ind=0;
for (int j=0; j<textInBetween.size(); j++) {
int currLength = pos;
pos = fn.indexOf(textInBetween[j], pos, Qt::CaseInsensitive);
fn = fn.replace(pos, textInBetween[j].length(), SEPARATOR);
if (pos == 0) {
currPosValue += textInBetween[j].length();
} else if (pos >0) {
currLength = pos - currLength;
tagSourceFNPositionsAndLengths[i][ind] = QPair<int, int>(currPosValue, currLength);
currPosValue += textInBetween[j].length() + currLength;
ind++;
}
// make sure, just inserted space is not considered again:
pos++;
}
if (ind == d-1) {
// last part of basename was a number
tagSourceFNPositionsAndLengths[i][ind] = QPair<int, int>(currPosValue, originalFilenameLength - currPosValue);
ind++;
} else if (ind != d) {
qWarning() << "error, problems with determining the positions and lengths of the "
" tag values for " << filenames[i] << " " << ind << " " << n-1;
return false;
}
QStringList values = fn.split(SEPARATOR, QString::SkipEmptyParts);
if (values.length() != d) {
qWarning() << "mismatching number of tags and found values";
filenameNumericValues[i].clear();
continue;
}
for (int j=0; j < d; j++) {
bool ok;
const int val = values[j].toInt(&ok);
filenameNumericValues[i][j] = ok ? val : QVariant(values[j]);
}
}
datePattern = datePattern.replace(SEPARATOR, " ");
return true;
}
QVector<int> FilenameNumbering_PRE::findMoveOrdering(
const QList<QPair<QString, QString> >& moveExisting
)
{
QVector<QString> currentExisting(moveExisting.size());
QList<QPair<QString, QString> > notHandled = moveExisting;
QVector<int> backMap(notHandled.size());
for (int i=0; i<notHandled.size(); i++) {
backMap[i] = i;
currentExisting[i] = moveExisting[i].first;
}
QVector<int> order;
int lastSize = order.size() - 1;
while (notHandled.size() > 0) {
if (lastSize == order.size()) {
qCritical() << "could not resolve movement, circular dependencies ?!";
return QVector<int>();
}
lastSize = order.size();
for (int i=notHandled.size()-1; i>=0; i--) {
const QString src = notHandled[i].first;
const QString target = notHandled[i].second;
// either the file does not exist or it exists but will be removed before
// current file gets moved
if (!currentExisting.contains(target) ) {
order.push_back(backMap[i]);
//added.push_back(notHandled[i].second);
//deleted.push_back(notHandled[i].first);
currentExisting.append(target);
if (currentExisting.contains(src)) {
currentExisting.remove(currentExisting.indexOf(src));
}
notHandled.removeAt(i);
backMap.remove(i);
}
}
}
return order;
}
template <>
template <>
Q_OUTOFLINE_TEMPLATE bool MyFilePartsList<QVariant>::operator==(const MyFilePartsList<QVariant> &b) const
{
if (size() != b.size()) {
return false;
}
bool same = true;
for (int i=0; i < (int)size(); i++) {
if (this->at(i).typeName() == b.at(i).typeName()) {
if (this->at(i).typeName() == QString("QString")) {
same &= this->at(i).toString() == b[i].toString();
}
} else {
same = false;
break;
}
}
return same;
}
} // end namespace MiscTools