//come throw all rules
foreach (ComputationalRules rule,rules)
{
if(!X1.empty())
{
if (Q1 == *findInSubsets(Qm,rule.to).begin())
{
X1.insert(rule.from);
}
else
{
X2.insert(rule.from);
}
}
else //for first create new Q1
{
QSet < QSet<QString> > tmp = findInSubsets(Qm,rule.to);
if(tmp.empty())
{
qFatal("Fatal error: in function bool FiniteAutomata::canDivide(FiniteAutomata FA ,QString symbol, QSet<QSet<QString> > Qm, QSet<QString> X, QSet<QString> &X1, QSet<QString> &X2)");
exit(1);
}
Q1 = *findInSubsets(Qm,rule.to).begin();
X1.insert(rule.from);
}
}
/*
Select all messages from a set of threads (passed as a set of mail.thread_id).
Return the number of selected messages.
*/
int
mail_listview::select_threads(const QSet<uint>& threads)
{
if (threads.empty())
return 0;
int cnt=0;
QStandardItem* item = model()->first_top_level_item();
QItemSelectionModel* sel = this->selectionModel();
while (item) {
QVariant v = item->data(mail_item_model::mail_msg_role);
mail_msg* msg = v.value<mail_msg*>();
QModelIndex index = item->index();
if (threads.contains(msg->thread_id())) {
DBG_PRINTF(4, "selecting index for mail_id=%d", msg->get_id());
sel->select(index, QItemSelectionModel::Select|QItemSelectionModel::Rows);
cnt++;
}
// next item
QModelIndex index_below = indexBelow(index);
if (index_below.isValid()) {
item = model()->itemFromIndex(index_below);
}
else
item=NULL;
}
return cnt;
}
void MThreadPool::waitForDone(void)
{
QMutexLocker locker(&m_priv->m_lock);
while (true)
{
while (!m_priv->m_delete_threads.empty())
{
m_priv->m_delete_threads.back()->wait();
delete m_priv->m_delete_threads.back();
m_priv->m_delete_threads.pop_back();
}
if (m_priv->m_running && !m_priv->m_run_queues.empty())
{
m_priv->m_wait.wait(locker.mutex());
continue;
}
QSet<MPoolThread*> working = m_priv->m_running_threads;
working = working.subtract(m_priv->m_avail_threads);
if (working.empty())
break;
m_priv->m_wait.wait(locker.mutex());
}
}
bool NodeElement::initPossibleEdges()
{
if (!mPossibleEdges.isEmpty()) {
return true;
}
const QStringList portTypes = mGraphicalAssistApi.editorManagerInterface().portTypes(id().type());
for (const QString &elementName : mGraphicalAssistApi.editorManagerInterface().elements(id().editor()
, id().diagram())) {
int ne = mGraphicalAssistApi.editorManagerInterface().isNodeOrEdge(id().editor(), elementName);
if (ne == -1) {
const QList<StringPossibleEdge> list = mGraphicalAssistApi.editorManagerInterface()
.possibleEdges(id().editor(), elementName);
for (const StringPossibleEdge &pEdge : list) {
if (portTypes.contains(pEdge.first.first)
|| (portTypes.contains(pEdge.first.second) && !pEdge.second.first))
{
PossibleEdgeType edge(pEdge.second.first, Id(id().editor(), id().diagram(), pEdge.second.second));
const QSet<ElementPair> elementPairs = elementsForPossibleEdge(pEdge);
if (elementPairs.empty()) {
continue;
}
for (const ElementPair &elementPair : elementPairs) {
mPossibleEdges.insert(qMakePair(elementPair, edge));
}
mPossibleEdgeTypes.insert(edge);
}
}
}
}
return !mPossibleEdges.isEmpty();
}
void FlyAI::changeRoute()
{
QSet<MoveDirection> moveDirections;
m_gameDataProvider->getMovesFromPoint(m_state.m_pos, moveDirections);
m_choosenMove = MoveDirection::MdUnknown;
if (moveDirections.empty())
{
qDebug() << "No move directions. Dying";
emit maxFlyingDistanceReached(); // todo: create correct signal
return;
}
int choosenIndex = int(frand() * (double)(moveDirections.count()));
auto dirIt = moveDirections.begin();
while(choosenIndex > 0)
{
dirIt ++;
--choosenIndex;
}
m_choosenMove = *dirIt;
m_targetSpot = m_gameDataProvider->getPointByDirection(m_state.m_pos, m_choosenMove);
std::shared_ptr<QPointF> part = m_gameDataProvider->getFreeLandingPoint(m_targetSpot);
if (!part)
{
qDebug() << "No moves. Dying";
emit maxFlyingDistanceReached(); // todo: create correct signal
return;
}
m_targetSpotPart = *part;
emit thinkTimeout(); // todo: create correct signal
}
//dodawanie kostki, ewentualnie wybuch; zwraca liczbę wybuchów
int CDisease::diseaseAppearsIn(CCity * source, int count)
{
if (cubesInGame.size() + count > maxNumberOfCubes) {
QMessageBox::critical(nullptr, "Game over!", DiseaseType_SL[color] + " cubes are exhausted");
return 0;
}
QSet<CCity*> processed = { source };
QSet<CCity*> toProcess;
int outbreaks = 0;
if (source->cubesOf(color) + count <= 3) { //nie będzie outbreaka
for (int i = 0; i < count; ++i)
addSingleCube(source);
}
else { //outbreak
for (int i = source->cubesOf(color); i < 3; ++i)
addSingleCube(source);
++outbreaks;
for (CCity *neighbour : source->neighbours())
toProcess += neighbour;
while (!toProcess.empty()) {
CCity *actual = *toProcess.begin();
toProcess -= actual;
processed += actual;
if (actual->cubesOf(color) == 3) {
++outbreaks;
for (CCity *neighbour : actual->neighbours())
if (!processed.contains(neighbour))
toProcess += neighbour;
}
else
addSingleCube(actual);
}
}
return outbreaks;
}
QList<Task*> DefaultConvertFileTask::onSubTaskFinished(Task *subTask) {
QList<Task*> result;
CHECK(!subTask->hasError() && !subTask->isCanceled(), result);
CHECK(!hasError() && !isCanceled(), result);
if (saveTask == subTask) {
return result;
}
SAFE_POINT_EXT(loadTask == subTask, setError("Unknown subtask"), result);
bool mainThread = false;
Document *srcDoc = loadTask->getDocument(mainThread);
SAFE_POINT_EXT(NULL != srcDoc, setError("NULL document"), result);
DocumentFormatRegistry *dfr = AppContext::getDocumentFormatRegistry();
DocumentFormat *df = dfr->getFormatById(targetFormat);
SAFE_POINT_EXT(NULL != df, setError("NULL document format"), result);
QSet<GObjectType> selectedFormatObjectsTypes = df->getSupportedObjectTypes();
QSet<GObjectType> inputFormatObjectTypes;
QListIterator<GObject*> objectsIterator(srcDoc->getObjects());
while (objectsIterator.hasNext()) {
GObject *obj = objectsIterator.next();
inputFormatObjectTypes << obj->getGObjectType();
}
inputFormatObjectTypes.intersect(selectedFormatObjectsTypes);
if (inputFormatObjectTypes.empty()) {
setError(tr("The formats are not compatible: %1 and %2").arg(srcDoc->getDocumentFormatId()).arg(targetFormat));
return result;
}
QString ext = targetFormat;
if (!df->getSupportedDocumentFileExtensions().isEmpty()) {
ext = df->getSupportedDocumentFileExtensions().first();
}
if (targetUrl.isEmpty()) {
QString fileName = srcDoc->getName() + "." + ext;
targetUrl = GUrlUtils::rollFileName(workingDir + fileName, QSet<QString>());
} else {
if (QFileInfo(targetFormat).suffix() != ext) {
targetUrl += "." + ext;
}
targetUrl = GUrlUtils::rollFileName(targetUrl, QSet<QString>());
}
IOAdapterFactory *iof = AppContext::getIOAdapterRegistry()->getIOAdapterFactoryById(IOAdapterUtils::url2io(srcDoc->getURL()));
Document *dstDoc = srcDoc->getSimpleCopy(df, iof, srcDoc->getURL());
saveTask = new SaveDocumentTask(dstDoc, iof, targetUrl);
result << saveTask;
return result;
}
bool Utils::Misc::isPreviewable(const QString &extension)
{
static QSet<QString> multimedia_extensions;
if (multimedia_extensions.empty()) {
multimedia_extensions.insert("3GP");
multimedia_extensions.insert("AAC");
multimedia_extensions.insert("AC3");
multimedia_extensions.insert("AIF");
multimedia_extensions.insert("AIFC");
multimedia_extensions.insert("AIFF");
multimedia_extensions.insert("ASF");
multimedia_extensions.insert("AU");
multimedia_extensions.insert("AVI");
multimedia_extensions.insert("FLAC");
multimedia_extensions.insert("FLV");
multimedia_extensions.insert("M3U");
multimedia_extensions.insert("M4A");
multimedia_extensions.insert("M4P");
multimedia_extensions.insert("M4V");
multimedia_extensions.insert("MID");
multimedia_extensions.insert("MKV");
multimedia_extensions.insert("MOV");
multimedia_extensions.insert("MP2");
multimedia_extensions.insert("MP3");
multimedia_extensions.insert("MP4");
multimedia_extensions.insert("MPC");
multimedia_extensions.insert("MPE");
multimedia_extensions.insert("MPEG");
multimedia_extensions.insert("MPG");
multimedia_extensions.insert("MPP");
multimedia_extensions.insert("OGG");
multimedia_extensions.insert("OGM");
multimedia_extensions.insert("OGV");
multimedia_extensions.insert("QT");
multimedia_extensions.insert("RA");
multimedia_extensions.insert("RAM");
multimedia_extensions.insert("RM");
multimedia_extensions.insert("RMV");
multimedia_extensions.insert("RMVB");
multimedia_extensions.insert("SWA");
multimedia_extensions.insert("SWF");
multimedia_extensions.insert("VOB");
multimedia_extensions.insert("WAV");
multimedia_extensions.insert("WMA");
multimedia_extensions.insert("WMV");
}
if (extension.isEmpty())
return false;
return multimedia_extensions.contains(extension.toUpper());
}
void ctkEventBusImpl::dispatchEvent(const ctkEvent& event, bool isAsync)
{
QString topic = event.topic();
QSet<ctkEventHandlerWrapper*> eventHandlers = this->handlers(topic);
if (eventHandlers.empty()) return;
QSetIterator<ctkEventHandlerWrapper*> iter(eventHandlers);
while (iter.hasNext())
{
iter.next()->handleEvent(event);
}
}
QSet<QString> ctkLDAPExpr::getMatchedObjectClasses() const
{
QSet<QString> objClasses;
if (d->m_operator == EQ)
{
if (d->m_attrName.compare(PluginConstants::OBJECTCLASS, Qt::CaseInsensitive) &&
d->m_attrValue.indexOf(WILDCARD) < 0)
{
objClasses.insert( d->m_attrValue );
}
}
else if (d->m_operator == AND)
{
for (int i = 0; i < d->m_args.size( ); i++) {
QSet<QString> r = d->m_args[i].getMatchedObjectClasses();
if ( !r.empty() ) {
if (objClasses.empty()) {
objClasses = r;
} else {
// if AND op and classes in several operands,
// then only the intersection is possible.
objClasses = r;
}
}
}
} else if (d->m_operator == OR) {
for (int i = 0; i < d->m_args.length( ); i++) {
QSet<QString> r = d->m_args[i].getMatchedObjectClasses();
if ( !r.empty() ) {
objClasses += r;
} else {
objClasses.clear();
break;
}
}
}
return objClasses;
}
/*!
\internal
This internal function supports the edge case where the \l Registry
is connected after \l Source objects are added to this \l Node, or
the connection to the \l Registry is lost. When connected/reconnected, this
function synchronizes local \l Source objects with the \l Registry.
*/
void QRemoteObjectRegistry::pushToRegistryIfNeeded()
{
if (!isReplicaValid())
return;
const QSet<QString> myLocs = QSet<QString>::fromList(hostedSources.keys());
if (myLocs.empty())
return;
const QSet<QString> registryLocs = QSet<QString>::fromList(sourceLocations().keys());
foreach (const QString &loc, myLocs & registryLocs) {
qCWarning(QT_REMOTEOBJECT) << "Node warning: Ignoring Source" << loc << "as another source ("
<< sourceLocations()[loc] << ") has already registered that name.";
hostedSources.remove(loc);
return;
}
void QgsComposerAttributeTableV2::setDisplayAttributes( const QSet<int>& attr, bool refresh )
{
QgsVectorLayer* source = sourceLayer();
if ( !source )
{
return;
}
//rebuild columns list, taking only attributes with index in supplied QSet
qDeleteAll( mColumns );
mColumns.clear();
const QgsFields& fields = source->pendingFields();
if ( !attr.empty() )
{
QSet<int>::const_iterator attIt = attr.constBegin();
for ( ; attIt != attr.constEnd(); ++attIt )
{
int attrIdx = ( *attIt );
if ( !fields.exists( attrIdx ) )
{
continue;
}
QString currentAlias = source->attributeDisplayName( attrIdx );
QgsComposerTableColumn* col = new QgsComposerTableColumn;
col->setAttribute( fields[attrIdx].name() );
col->setHeading( currentAlias );
mColumns.append( col );
}
}
else
{
//resetting, so add all attributes to columns
for ( int idx = 0; idx < fields.count(); ++idx )
{
QString currentAlias = source->attributeDisplayName( idx );
QgsComposerTableColumn* col = new QgsComposerTableColumn;
col->setAttribute( fields[idx].name() );
col->setHeading( currentAlias );
mColumns.append( col );
}
}
if ( refresh )
{
refreshAttributes();
}
}
QHash<Cell*, QSet<char> > Grid::fixArcConsistency(Cell* dirtyCell)
{
QHash<Cell*, QSet<char> > changes;
QQueue<Cell*> dirtyCells;
// initialize the set of cells to check
// if no dirty cell specified, assume all are dirty
if( dirtyCell != nullptr ){
auto depCells = dirtyCell->dependentCells();
for( auto dep=depCells.constBegin(); dep!=depCells.constEnd(); ++dep )
{
dirtyCells.enqueue(*dep);
}
}
else {
for( int i=0; i<cells.count(); i++ ){
dirtyCells.enqueue( cells.at(i) );
}
}
// loop until there are no more dirty cells
while( !dirtyCells.empty() )
{
// update domain of dirty cell
Cell* cell = dirtyCells.dequeue();
QSet<char> cellChanges = cell->restrictDomain();
// if the domain changes
if( !cellChanges.empty() )
{
// add changes to the running diff
changes[cell] += cellChanges;
// add dependents to queue
auto depCells = cell->dependentCells();
for( auto dep=depCells.constBegin(); dep!=depCells.constEnd(); ++dep )
{
dirtyCells.enqueue(*dep);
}
}
// else nothing to be done
}
return changes;
}
void tst_QSet::size()
{
QSet<int> set;
QVERIFY(set.size() == 0);
QVERIFY(set.isEmpty());
QVERIFY(set.count() == set.size());
QVERIFY(set.isEmpty() == set.empty());
set.insert(1);
QVERIFY(set.size() == 1);
QVERIFY(!set.isEmpty());
QVERIFY(set.count() == set.size());
QVERIFY(set.isEmpty() == set.empty());
set.insert(1);
QVERIFY(set.size() == 1);
QVERIFY(!set.isEmpty());
QVERIFY(set.count() == set.size());
QVERIFY(set.isEmpty() == set.empty());
set.insert(2);
QVERIFY(set.size() == 2);
QVERIFY(!set.isEmpty());
QVERIFY(set.count() == set.size());
QVERIFY(set.isEmpty() == set.empty());
set.remove(1);
QVERIFY(set.size() == 1);
QVERIFY(!set.isEmpty());
QVERIFY(set.count() == set.size());
QVERIFY(set.isEmpty() == set.empty());
set.remove(1);
QVERIFY(set.size() == 1);
QVERIFY(!set.isEmpty());
QVERIFY(set.count() == set.size());
QVERIFY(set.isEmpty() == set.empty());
set.remove(2);
QVERIFY(set.size() == 0);
QVERIFY(set.isEmpty());
QVERIFY(set.count() == set.size());
QVERIFY(set.isEmpty() == set.empty());
}
//dodawanie kostki, ewentualnie wybuch; zwraca liczbê wybuchów
void Disease::diseaseAppearsIn(City *source, int count)
{
if (markersLeft - count < 0)
{
Board::WinOrLoose(LOST_CUBES);
}
QSet<City*> processed = { source };
QSet<City*> toProcess;
if (source->DiseaseCounter(diseaseID) + count <= 3)
{ //nie bêdzie outbreaka
for (int i = 0; i < count; ++i)
{
addSingleCube(source);
}
}
else
{ //outbreak
for (int i = source->DiseaseCounter(diseaseID); i<3; ++i)
addSingleCube(source);
Board::Outbreak();
for (City *neighbour : source->Neighbours())
toProcess += neighbour;
while (!toProcess.empty())
{
City *actual = *toProcess.begin();
toProcess -= actual;
processed += actual;
if (actual->DiseaseCounter(diseaseID) == 3)
{
Board::Outbreak(); //mozna zlapac tutaj i dodac info, ktore poleca wyzej
for (City *neighbour : actual->Neighbours())
if (!processed.contains(neighbour))
toProcess += neighbour;
}
else
addSingleCube(actual);
}
}
return;
}
void ArbitAssignments::helperAssignMove(const Move &iMove)
{
QSet<unsigned int> playersIdSet = getSelectedPlayers();
// Warn if some of the selected players already have an assigned move
QSet<unsigned int> assignedIdSet;
BOOST_FOREACH(unsigned int id, playersIdSet)
{
if (m_game->hasPlayed(id) &&
!m_game->getPlayer(id).getLastMove().isNull())
{
assignedIdSet.insert(id);
}
}
if (!assignedIdSet.empty())
{
QString players;
BOOST_FOREACH(unsigned int id, assignedIdSet)
{
players = QString("\t%1\n").arg(qfw(m_game->getPlayer(id).getName()));
}
void BeatController::processNewData()
{
m_FFT->processData();
m_Analyser->processData();
emit processingDone();
if(m_Analyser->getDrumBeat())
emit beatDrum();
if(m_Analyser->getSnareBeat())
emit beatSnare();
//Check for a beat for every frequency in our list
QSet<uint16_t> myBeats;
QSetIterator<uint16_t> i(m_customBeats);
while(i.hasNext())
{
if(m_Analyser->getBeatFrequency(i.peekNext()))
myBeats.insert(i.peekNext());
i.next();
}
if(!myBeats.empty())
emit beatCustom(myBeats);
}
void MThread::Cleanup(void)
{
QMutexLocker locker(&s_all_threads_lock);
QSet<MThread*> badGuys;
QSet<MThread*>::const_iterator it;
for (it = s_all_threads.begin(); it != s_all_threads.end(); ++it)
{
if ((*it)->isRunning())
{
badGuys.insert(*it);
(*it)->exit(1);
}
}
if (badGuys.empty())
return;
// logging has been stopped so we need to use iostream...
cerr<<"Error: Not all threads were shut down properly: "<<endl;
for (it = badGuys.begin(); it != badGuys.end(); ++it)
{
cerr<<"Thread "<<qPrintable((*it)->objectName())
<<" is still running"<<endl;
}
cerr<<endl;
static const int kTimeout = 5000;
MythTimer t;
t.start();
for (it = badGuys.begin();
it != badGuys.end() && t.elapsed() < kTimeout; ++it)
{
int left = kTimeout - t.elapsed();
if (left > 0)
(*it)->wait(left);
}
}
bool DataStore::setItemsFlags(const PimItem::List &items, const QVector<Flag> &flags,
bool *flagsChanged, const Collection &col_, bool silent)
{
QSet<QByteArray> removedFlags;
QSet<QByteArray> addedFlags;
QVariantList insIds;
QVariantList insFlags;
Query::Condition delConds(Query::Or);
Collection col = col_;
setBoolPtr(flagsChanged, false);
for (const PimItem &item : items) {
const Flag::List itemFlags = item.flags();
Q_FOREACH (const Flag &flag, itemFlags) {
if (!flags.contains(flag)) {
removedFlags << flag.name().toLatin1();
Query::Condition cond;
cond.addValueCondition(PimItemFlagRelation::leftFullColumnName(), Query::Equals, item.id());
cond.addValueCondition(PimItemFlagRelation::rightFullColumnName(), Query::Equals, flag.id());
delConds.addCondition(cond);
}
}
Q_FOREACH (const Flag &flag, flags) {
if (!itemFlags.contains(flag)) {
addedFlags << flag.name().toLatin1();
insIds << item.id();
insFlags << flag.id();
}
}
if (col.id() == -1) {
col.setId(item.collectionId());
} else if (col.id() != item.collectionId()) {
col.setId(-2);
}
}
if (!removedFlags.empty()) {
QueryBuilder qb(PimItemFlagRelation::tableName(), QueryBuilder::Delete);
qb.addCondition(delConds);
if (!qb.exec()) {
return false;
}
}
if (!addedFlags.empty()) {
QueryBuilder qb2(PimItemFlagRelation::tableName(), QueryBuilder::Insert);
qb2.setColumnValue(PimItemFlagRelation::leftColumn(), insIds);
qb2.setColumnValue(PimItemFlagRelation::rightColumn(), insFlags);
qb2.setIdentificationColumn(QString());
if (!qb2.exec()) {
return false;
}
}
if (!silent && (!addedFlags.isEmpty() || !removedFlags.isEmpty())) {
mNotificationCollector->itemsFlagsChanged(items, addedFlags, removedFlags, col);
}
setBoolPtr(flagsChanged, (addedFlags != removedFlags));
return true;
}
void FlyAI::advanceThinking()
{
double dt = m_dt;
m_state.m_age += dt;
if (m_state.m_age > m_maxAge)
{
emit(maxAgeReached());
return;
}
QSet<MoveDirection> moveDirections;
m_gameDataProvider->getMovesFromPoint(m_state.m_pos, moveDirections);
if (moveDirections.empty())
{
m_choosenMove = MoveDirection::MdUnknown;
//qDebug() << "No move directions. Waiting";
return;
}
m_thinkingTime += dt;
bool timeIsElapsed = m_thinkingTime >= m_maxThinkTime * FlyAI::MinThinkElaps;
bool maxTimeIsElapsed = m_thinkingTime >= m_maxThinkTime;
if (m_choosenMove == MoveDirection::MdUnknown || !moveDirections.contains(m_choosenMove) || frand() > 0.95)
{
int choosenIndex = int(frand() * (double)(moveDirections.count()));
auto dirIt = moveDirections.begin();
while(choosenIndex > 0)
{
dirIt ++;
--choosenIndex;
}
m_choosenMove = *dirIt;
}
m_state.m_angle = angleFromDirection(m_choosenMove);
if (timeIsElapsed)
{
if (frand() > 0.5)
{
if (m_choosenMove != MoveDirection::MdUnknown && moveDirections.contains(m_choosenMove))
{
m_targetSpot = m_gameDataProvider->getPointByDirection(m_state.m_pos, m_choosenMove);
}
else
{
int choosenIndex = int(frand() * (double)(moveDirections.count()));
auto dirIt = moveDirections.begin();
while(choosenIndex > 0)
{
dirIt ++;
--choosenIndex;
}
m_choosenMove = *dirIt;
m_targetSpot = m_gameDataProvider->getPointByDirection(m_state.m_pos, m_choosenMove);
}
std::shared_ptr<QPointF> part = m_gameDataProvider->getFreeLandingPoint(m_targetSpot);
if (!part)
{
qWarning() << "Can't move to choosen direction. Continue thinking";
return;
}
m_targetSpotPart = *part;
qDebug() << "Direction: " << m_choosenMove << " target spot: " << m_targetSpotPart << "(" << m_targetSpot << ")";
emit(thinkTimeout());
}
}
if (maxTimeIsElapsed)
{
if (m_choosenMove != MoveDirection::MdUnknown && moveDirections.contains(m_choosenMove))
{
m_targetSpot = m_gameDataProvider->getPointByDirection(m_state.m_pos, m_choosenMove);
}
else
{
m_targetSpot = m_gameDataProvider->getPointByDirection(m_state.m_pos, *(moveDirections.begin()));
}
std::shared_ptr<QPointF> part = m_gameDataProvider->getFreeLandingPoint(m_targetSpot);
if (!part)
{
qWarning() << "Can't move to choosen direction. Continue thinking";
return;
}
m_targetSpotPart = *part;
qDebug() << "Direction: " << m_choosenMove << " target spot: " << m_targetSpotPart << "(" << m_targetSpot << ")";
emit(thinkTimeout());
}
}
QT_BEGIN_NAMESPACE
static const QSet<QString> &qscriptKeywords() {
static QSet<QString> keywords;
if (keywords.empty()) {
keywords.insert(QLatin1String("Infinity"));
keywords.insert(QLatin1String("NaN"));
keywords.insert(QLatin1String("abstract"));
keywords.insert(QLatin1String("boolean"));
keywords.insert(QLatin1String("break"));
keywords.insert(QLatin1String("byte"));
keywords.insert(QLatin1String("case"));
keywords.insert(QLatin1String("catch"));
keywords.insert(QLatin1String("char"));
keywords.insert(QLatin1String("class"));
keywords.insert(QLatin1String("const"));
keywords.insert(QLatin1String("constructor"));
keywords.insert(QLatin1String("continue"));
keywords.insert(QLatin1String("debugger"));
keywords.insert(QLatin1String("default"));
keywords.insert(QLatin1String("delete"));
keywords.insert(QLatin1String("do"));
keywords.insert(QLatin1String("double"));
keywords.insert(QLatin1String("else"));
keywords.insert(QLatin1String("enum"));
keywords.insert(QLatin1String("export"));
keywords.insert(QLatin1String("extends"));
keywords.insert(QLatin1String("false"));
keywords.insert(QLatin1String("final"));
keywords.insert(QLatin1String("finally"));
keywords.insert(QLatin1String("float"));
keywords.insert(QLatin1String("for"));
keywords.insert(QLatin1String("function"));
keywords.insert(QLatin1String("goto"));
keywords.insert(QLatin1String("if"));
keywords.insert(QLatin1String("implements"));
keywords.insert(QLatin1String("import"));
keywords.insert(QLatin1String("in"));
keywords.insert(QLatin1String("instanceof"));
keywords.insert(QLatin1String("int"));
keywords.insert(QLatin1String("interface"));
keywords.insert(QLatin1String("long"));
keywords.insert(QLatin1String("native"));
keywords.insert(QLatin1String("new"));
keywords.insert(QLatin1String("package"));
keywords.insert(QLatin1String("private"));
keywords.insert(QLatin1String("protected"));
keywords.insert(QLatin1String("public"));
keywords.insert(QLatin1String("return"));
keywords.insert(QLatin1String("short"));
keywords.insert(QLatin1String("static"));
keywords.insert(QLatin1String("super"));
keywords.insert(QLatin1String("switch"));
keywords.insert(QLatin1String("synchronized"));
keywords.insert(QLatin1String("this"));
keywords.insert(QLatin1String("throw"));
keywords.insert(QLatin1String("throws"));
keywords.insert(QLatin1String("transient"));
keywords.insert(QLatin1String("true"));
keywords.insert(QLatin1String("try"));
keywords.insert(QLatin1String("typeof"));
keywords.insert(QLatin1String("undefined"));
keywords.insert(QLatin1String("var"));
keywords.insert(QLatin1String("void"));
keywords.insert(QLatin1String("volatile"));
keywords.insert(QLatin1String("while"));
keywords.insert(QLatin1String("with")); // end
}
return keywords;
}
QgsRasterBlock *QgsMultiBandColorRenderer::block( int bandNo, QgsRectangle const &extent, int width, int height, QgsRasterBlockFeedback *feedback )
{
Q_UNUSED( bandNo );
std::unique_ptr< QgsRasterBlock > outputBlock( new QgsRasterBlock() );
if ( !mInput )
{
return outputBlock.release();
}
//In some (common) cases, we can simplify the drawing loop considerably and save render time
bool fastDraw = ( !usesTransparency()
&& mRedBand > 0 && mGreenBand > 0 && mBlueBand > 0
&& mAlphaBand < 1 );
QSet<int> bands;
if ( mRedBand > 0 )
{
bands << mRedBand;
}
if ( mGreenBand > 0 )
{
bands << mGreenBand;
}
if ( mBlueBand > 0 )
{
bands << mBlueBand;
}
if ( bands.empty() )
{
// no need to draw anything if no band is set
// TODO:: we should probably return default color block
return outputBlock.release();
}
if ( mAlphaBand > 0 )
{
bands << mAlphaBand;
}
QMap<int, QgsRasterBlock *> bandBlocks;
QgsRasterBlock *defaultPointer = nullptr;
QSet<int>::const_iterator bandIt = bands.constBegin();
for ( ; bandIt != bands.constEnd(); ++bandIt )
{
bandBlocks.insert( *bandIt, defaultPointer );
}
QgsRasterBlock *redBlock = nullptr;
QgsRasterBlock *greenBlock = nullptr;
QgsRasterBlock *blueBlock = nullptr;
QgsRasterBlock *alphaBlock = nullptr;
bandIt = bands.constBegin();
for ( ; bandIt != bands.constEnd(); ++bandIt )
{
bandBlocks[*bandIt] = mInput->block( *bandIt, extent, width, height, feedback );
if ( !bandBlocks[*bandIt] )
{
// We should free the alloced mem from block().
QgsDebugMsg( QStringLiteral( "No input band" ) );
--bandIt;
for ( ; bandIt != bands.constBegin(); --bandIt )
{
delete bandBlocks[*bandIt];
}
return outputBlock.release();
}
}
if ( mRedBand > 0 )
{
redBlock = bandBlocks[mRedBand];
}
if ( mGreenBand > 0 )
{
greenBlock = bandBlocks[mGreenBand];
}
if ( mBlueBand > 0 )
{
blueBlock = bandBlocks[mBlueBand];
}
if ( mAlphaBand > 0 )
{
alphaBlock = bandBlocks[mAlphaBand];
}
if ( !outputBlock->reset( Qgis::ARGB32_Premultiplied, width, height ) )
{
for ( int i = 0; i < bandBlocks.size(); i++ )
{
delete bandBlocks.value( i );
}
return outputBlock.release();
}
QRgb *outputBlockColorData = outputBlock->colorData();
// faster data access to data for the common case that input data are coming from RGB image with 8-bit bands
bool hasByteRgb = ( redBlock && greenBlock && blueBlock && redBlock->dataType() == Qgis::Byte && greenBlock->dataType() == Qgis::Byte && blueBlock->dataType() == Qgis::Byte );
const quint8 *redData = nullptr, *greenData = nullptr, *blueData = nullptr;
if ( hasByteRgb )
{
redData = redBlock->byteData();
greenData = greenBlock->byteData();
blueData = blueBlock->byteData();
}
QRgb myDefaultColor = NODATA_COLOR;
if ( fastDraw )
{
// By default RGB raster layers have contrast enhancement assigned and normally that requires us to take the slow
// route that applies the enhancement. However if the algorithm type is "no enhancement" and all input bands are byte-sized,
// no transform would be applied to the input values and we can take the fast route.
bool hasEnhancement;
if ( hasByteRgb )
{
hasEnhancement =
( mRedContrastEnhancement && mRedContrastEnhancement->contrastEnhancementAlgorithm() != QgsContrastEnhancement::NoEnhancement ) ||
( mGreenContrastEnhancement && mGreenContrastEnhancement->contrastEnhancementAlgorithm() != QgsContrastEnhancement::NoEnhancement ) ||
( mBlueContrastEnhancement && mBlueContrastEnhancement->contrastEnhancementAlgorithm() != QgsContrastEnhancement::NoEnhancement );
}
else
{
hasEnhancement = mRedContrastEnhancement || mGreenContrastEnhancement || mBlueContrastEnhancement;
}
if ( hasEnhancement )
fastDraw = false;
}
qgssize count = ( qgssize )width * height;
for ( qgssize i = 0; i < count; i++ )
{
if ( fastDraw ) //fast rendering if no transparency, stretching, color inversion, etc.
{
if ( redBlock->isNoData( i ) ||
greenBlock->isNoData( i ) ||
blueBlock->isNoData( i ) )
{
outputBlock->setColor( i, myDefaultColor );
}
else
{
if ( hasByteRgb )
{
outputBlockColorData[i] = qRgb( redData[i], greenData[i], blueData[i] );
}
else
{
int redVal = static_cast<int>( redBlock->value( i ) );
int greenVal = static_cast<int>( greenBlock->value( i ) );
int blueVal = static_cast<int>( blueBlock->value( i ) );
outputBlockColorData[i] = qRgb( redVal, greenVal, blueVal );
}
}
continue;
}
bool isNoData = false;
double redVal = 0;
double greenVal = 0;
double blueVal = 0;
if ( mRedBand > 0 )
{
redVal = redBlock->value( i );
if ( redBlock->isNoData( i ) ) isNoData = true;
}
if ( !isNoData && mGreenBand > 0 )
{
greenVal = greenBlock->value( i );
if ( greenBlock->isNoData( i ) ) isNoData = true;
}
if ( !isNoData && mBlueBand > 0 )
{
blueVal = blueBlock->value( i );
if ( blueBlock->isNoData( i ) ) isNoData = true;
}
if ( isNoData )
{
outputBlock->setColor( i, myDefaultColor );
continue;
}
//apply default color if red, green or blue not in displayable range
if ( ( mRedContrastEnhancement && !mRedContrastEnhancement->isValueInDisplayableRange( redVal ) )
|| ( mGreenContrastEnhancement && !mGreenContrastEnhancement->isValueInDisplayableRange( redVal ) )
|| ( mBlueContrastEnhancement && !mBlueContrastEnhancement->isValueInDisplayableRange( redVal ) ) )
{
outputBlock->setColor( i, myDefaultColor );
continue;
}
//stretch color values
if ( mRedContrastEnhancement )
{
redVal = mRedContrastEnhancement->enhanceContrast( redVal );
}
if ( mGreenContrastEnhancement )
{
greenVal = mGreenContrastEnhancement->enhanceContrast( greenVal );
}
if ( mBlueContrastEnhancement )
{
blueVal = mBlueContrastEnhancement->enhanceContrast( blueVal );
}
//opacity
double currentOpacity = mOpacity;
if ( mRasterTransparency )
{
currentOpacity = mRasterTransparency->alphaValue( redVal, greenVal, blueVal, mOpacity * 255 ) / 255.0;
}
if ( mAlphaBand > 0 )
{
currentOpacity *= alphaBlock->value( i ) / 255.0;
}
if ( qgsDoubleNear( currentOpacity, 1.0 ) )
{
outputBlock->setColor( i, qRgba( redVal, greenVal, blueVal, 255 ) );
}
else
{
outputBlock->setColor( i, qRgba( currentOpacity * redVal, currentOpacity * greenVal, currentOpacity * blueVal, currentOpacity * 255 ) );
}
}
//delete input blocks
QMap<int, QgsRasterBlock *>::const_iterator bandDelIt = bandBlocks.constBegin();
for ( ; bandDelIt != bandBlocks.constEnd(); ++bandDelIt )
{
delete bandDelIt.value();
}
return outputBlock.release();
}
