/** * @brief cwRegionLoadTask::loadSurveyChunk * @param protoChunk * @param chunk */ void cwRegionLoadTask::loadSurveyChunk(const CavewhereProto::SurveyChunk& protoChunk, cwSurveyChunk *chunk) { QList<cwStation> stations; stations.reserve(protoChunk.stations_size()); for(int i = 0 ; i < protoChunk.stations_size(); i++) { cwStation station = loadStation(protoChunk.stations(i)); stations.append(station); } QList<cwShot> shots; shots.reserve(protoChunk.shots_size()); for(int i = 0; i < protoChunk.shots_size(); i++) { cwShot shot = loadShot(protoChunk.shots(i)); shots.append(shot); } if(stations.count() - 1 != shots.count()) { qDebug() << "Shot, station count mismatch, survey chunk invalid:" << stations.count() << shots.count(); return; } for(int i = 0; i < stations.count() - 1; i++) { cwStation fromStation = stations[i]; cwStation toStation = stations[i + 1]; cwShot shot = shots[i]; chunk->appendShot(fromStation, toStation, shot); } }
/** * @brief cwRegionLoadTask::loadScrap * @param protoScrap * @param scrap */ void cwRegionLoadTask::loadScrap(const CavewhereProto::Scrap& protoScrap, cwScrap *scrap) { QVector<QPointF> outlinePoint; outlinePoint.resize(protoScrap.outlinepoints_size()); for(int i = 0; i < protoScrap.outlinepoints_size(); i++) { outlinePoint[i] = loadPointF(protoScrap.outlinepoints(i)); } scrap->setPoints(outlinePoint); QList<cwNoteStation> stations; stations.reserve(protoScrap.notestations_size()); for(int i = 0; i < protoScrap.notestations_size(); i++) { stations.append(loadNoteStation(protoScrap.notestations(i))); } scrap->setStations(stations); QList<cwLead> leads; leads.reserve(protoScrap.leads_size()); for(int i = 0; i < protoScrap.leads_size(); i++) { leads.append(loadLead(protoScrap.leads(i))); } scrap->setLeads(leads); loadNoteTranformation(protoScrap.notetransformation(), scrap->noteTransformation()); scrap->setCalculateNoteTransform(protoScrap.calculatenotetransform()); scrap->setTriangulationData(loadTriangulatedData(protoScrap.triangledata())); scrap->setType((cwScrap::ScrapType)protoScrap.type()); }
void Document::separableFilter(const QVector<qreal> &filter) { if (std::min(m_selection.height(), m_selection.width()) < filter.size()) { qWarning() << "Too large filter!"; } if (filter.size() < 2) { qWarning() << "Filter size must be at least 2"; } qDebug() << "separableFilter(" << filter << ")"; int n = filter.size() - 1; QList<ConcurrentLinearFilter> jobs; jobs.reserve(m_selection.height()); for (int line = m_selection.top(); line <= m_selection.bottom(); ++line) { QVector<QRgb> head(n); for (int i = 0; i < n; ++i) head[i] = m_image.pixel(abs(m_selection.x() - n + i), line); QVector<QRgb> tail(n); for (int i = 0; i < n; ++i) { int x = m_selection.right() + 1 + i; if (x >= m_image.width()) x = 2 * m_image.width() - x - 1; tail[i] = m_image.pixel(x, line); } jobs.append(ConcurrentLinearFilter(filter, head, tail, m_selection.width(), sizeof(QRgb), m_image.scanLine(line) + m_selection.left() * sizeof(QRgb))); } QtConcurrent::blockingMap(jobs, ConcurrentLinearFilter::process); jobs.clear(); jobs.reserve(m_selection.width()); for (int column = m_selection.left(); column <= m_selection.right(); ++column) { QVector<QRgb> head(n); for (int i = 0; i < n; ++i) head[i] = m_image.pixel(column, abs(m_selection.top() - n + i)); QVector<QRgb> tail(n); for (int i = 0; i < n; ++i) { int y = m_selection.bottom() + 1 + i; if (y >= m_image.height()) y = 2 * m_image.height() - y - 1; tail[i] = m_image.pixel(column, y); } jobs.append(ConcurrentLinearFilter(filter, head, tail, m_selection.height(), m_image.bytesPerLine(), m_image.scanLine(m_selection.top()) + column * sizeof(QRgb))); } QtConcurrent::blockingMap(jobs, ConcurrentLinearFilter::process); setModified(true); emit repaint(m_selection); }
//! populate two lists (ks, vs) from map - in reverse order template <class Key, class T> void mapToReversedLists( const QMap< Key, T >& map, QList<Key>& ks, QList<T>& vs ) { ks.reserve( map.size() ); vs.reserve( map.size() ); typename QMap<Key, T>::const_iterator i = map.constEnd(); while ( i-- != map.constBegin() ) { ks.append( i.key() ); vs.append( i.value() ); } }
QString SeasideCache::exportContacts() { QVersitContactExporter exporter; QList<QContact> contacts; contacts.reserve(instance->m_people.count()); QList<QContactLocalId> contactsToFetch; contactsToFetch.reserve(instance->m_people.count()); const QContactLocalId selfId = instance->m_manager.selfContactId(); typedef QHash<QContactLocalId, SeasideCacheItem>::iterator iterator; for (iterator it = instance->m_people.begin(); it != instance->m_people.end(); ++it) { if (it.key() == selfId) { continue; } else if (it->hasCompleteContact) { contacts.append(it->contact); } else { contactsToFetch.append(it.key()); } } if (!contactsToFetch.isEmpty()) { QList<QContact> fetchedContacts = instance->m_manager.contacts(contactsToFetch); contacts.append(fetchedContacts); } if (!exporter.exportContacts(contacts)) { qWarning() << Q_FUNC_INFO << "Failed to export contacts: " << exporter.errorMap(); return QString(); } QFile vcard(QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation) + QDir::separator() + QDateTime::currentDateTime().toString("ss_mm_hh_dd_mm_yyyy") + ".vcf"); if (!vcard.open(QIODevice::WriteOnly)) { qWarning() << "Cannot open " << vcard.fileName(); return QString(); } QVersitWriter writer(&vcard); if (!writer.startWriting(exporter.documents())) { qWarning() << Q_FUNC_INFO << "Can't start writing vcards " << writer.error(); return QString(); } // TODO: thread writer.waitForFinished(); return vcard.fileName(); }
void GeoTreeModel::addChildren(GeoObjectListItem* sfcList, GeoLib::SurfaceVec const& surface_vec, size_t start_index, size_t end_index) { const std::vector<GeoLib::Surface*>* surfaces = surface_vec.getVector(); const std::vector<GeoLib::Point*> &nodesVec(*((*surfaces)[start_index]->getPointVec())); for (size_t i = start_index; i < end_index; i++) { QList<QVariant> surface; surface.reserve(4); surface << "Surface " + QString::number(i) << "" << "" << ""; const GeoLib::Surface &sfc(*(*surfaces)[i]); GeoTreeItem* surfaceItem(new GeoTreeItem(surface, sfcList, &sfc)); sfcList->appendChild(surfaceItem); int nElems = static_cast<int>((*surfaces)[i]->getNTriangles()); for (int j = 0; j < nElems; j++) { QList<QVariant> elem; elem.reserve(4); const GeoLib::Triangle &triangle(*sfc[j]); elem << j << static_cast<int>(triangle[0]) << static_cast<int>(triangle[1]) << static_cast<int>(triangle[2]); TreeItem* child(new TreeItem(elem, surfaceItem)); surfaceItem->appendChild(child); for (int k = 0; k < 3; k++) { QList<QVariant> node; node.reserve(4); const GeoLib::Point &pnt(*(nodesVec[triangle[k]])); node << static_cast<int>(triangle[k]) << QString::number(pnt[0], 'f') << QString::number(pnt[1], 'f') << QString::number(pnt[2], 'f'); child->appendChild(new TreeItem(node, child)); } } } for (auto pnt = surface_vec.getNameIDMapBegin(); pnt != surface_vec.getNameIDMapEnd(); ++pnt) QVariant pnt_data (sfcList->child(pnt->second)->setData(1, QString::fromStdString(pnt->first))); INFO("%d surfaces added.", end_index - start_index); }
void MeshGenerator::fillNeighborStructures() { QList<QSet<int> > vertexElements; vertexElements.reserve(nodeList.count()); for (int i = 0; i < nodeList.count(); i++) vertexElements.push_back(QSet<int>()); for (int i = 0; i < elementList.count(); i++) if (elementList[i].isUsed) for (int elemNode = 0; elemNode < (elementList[i].isTriangle() ? 3 : 4); elemNode++) vertexElements[elementList[i].node[elemNode]].insert(i); for (int i = 0; i < edgeList.count(); i++) { if (edgeList[i].isUsed && edgeList[i].marker != -1) { QSet<int> neighbours = vertexElements[edgeList[i].node[0]]; neighbours.intersect(vertexElements[edgeList[i].node[1]]); assert((neighbours.size() > 0) && (neighbours.size() <= 2)); edgeList[i].neighElem[0] = neighbours.values()[0]; if (neighbours.size() == 2) edgeList[i].neighElem[1] = neighbours.values()[1]; } } }
bool GenericEditableTableModel::insertRows ( int row, int count, const QModelIndex & parent) { if(row<0 || row>rowCount()){ return false; } beginInsertRows(parent, row, row+count-1); modelData.reserve(rowCount()+count); int colCount=columnCount(); int currentRowCount=rowCount(); for(int i=0; i<count; i++){ QList<QHash<int,QVariant> > newCols; newCols.reserve(colCount); for(int j=0; j<colCount; j++){ newCols.append(QHash<int,QVariant>()); } if(row==currentRowCount){ modelData.append(newCols); }else{ modelData.insert(row+i, newCols); } } endInsertRows(); return true; }
void initialize(const FileList &targetFiles, const FileList &queryFiles) { Output::initialize(targetFiles, queryFiles); bestMatches.reserve(queryFiles.size()); for (int i=0; i<queryFiles.size(); i++) bestMatches.append(BestMatch(-std::numeric_limits<float>::max(), QPair<int,int>(-1, -1))); }
void FollowupReminderInfoDialogTest::shouldAddItemInTreeList() { FollowUpReminderInfoDialog dlg; FollowUpReminderInfoWidget *infowidget = dlg.findChild<FollowUpReminderInfoWidget *>(QStringLiteral("FollowUpReminderInfoWidget")); QTreeWidget *treeWidget = infowidget->findChild<QTreeWidget *>(QStringLiteral("treewidget")); QList<FollowUpReminder::FollowUpReminderInfo *> lstInfo; lstInfo.reserve(10); for (int i = 0; i < 10; ++i) { FollowUpReminder::FollowUpReminderInfo *info = new FollowUpReminder::FollowUpReminderInfo(); lstInfo.append(info); } dlg.setInfo(lstInfo); //We load invalid infos. QCOMPARE(treeWidget->topLevelItemCount(), 0); //Load valid infos for (int i = 0; i < 10; ++i) { FollowUpReminder::FollowUpReminderInfo *info = new FollowUpReminder::FollowUpReminderInfo(); info->setOriginalMessageItemId(42); info->setMessageId(QStringLiteral("foo")); info->setFollowUpReminderDate(QDate::currentDate()); info->setTo(QStringLiteral("To")); lstInfo.append(info); } dlg.setInfo(lstInfo); QCOMPARE(treeWidget->topLevelItemCount(), 10); }
static QList<double> _calcEqualIntervalBreaks( double minimum, double maximum, int classes ) { // Equal interval algorithm // // Returns breaks based on dividing the range ('minimum' to 'maximum') // into 'classes' parts. double step = ( maximum - minimum ) / classes; QList<double> breaks; double value = minimum; breaks.reserve( classes ); for ( int i = 0; i < classes; i++ ) { value += step; breaks.append( value ); } // floating point arithmetics is not precise: // set the last break to be exactly maximum so we do not miss it breaks[classes-1] = maximum; return breaks; }
void CookieJar::load() { QFile cookieFile(m_cookieFileName); if (!cookieFile.open(QIODevice::ReadOnly)) return; QDataStream stream(&cookieFile); quint8 version; stream >> version; if (version != cookieFileVersion) return; QList<QNetworkCookie> cookies; qint32 count; stream >> count; #if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0) cookies.reserve(count); #endif for (int i = 0; i < count && !stream.atEnd(); ++i) { QByteArray rawCookie; stream >> rawCookie; cookies += QNetworkCookie::parseCookies(rawCookie); } setAllCookies(cookies); expireCookies(); }
QList<float> pool(const Mat &bottom, const Mat &top) const { QList<float> features; for (int i=0; i<=top.rows-3; i+=3) { for (int j=0; j<=top.cols-3; j+=3) { QList<float> vals; vals.reserve(3*3 + 4*4); // Top values for (int k=0; k<3; k++) { const float *data = top.ptr<float>(i+k, j); for (int l=0; l<3; l++) vals.append(data[l]); } // Bottom values for (int k=0; k<4; k++) { const float *data = bottom.ptr<float>(4*i/3+k, 4*j/3); for (int l=0; l<4; l++) vals.append(data[l]); } double mean, stddev; Common::MeanStdDev(vals, &mean, &stddev); features.append(mean); features.append(stddev); } } return features; }
QList<VDPtr> VideoDevice::getSystemDevices() { auto udevs = VideoDeviceImpl::getSystemDevices(); QList<VDPtr> devs; devs.reserve(udevs.size()); foreach (const auto &dev, udevs) { devs << VDPtr(new VideoDevice(dev)); }
void QIdentityProxyModelPrivate::_q_sourceLayoutChanged(const QList<QPersistentModelIndex> &sourceParents, QAbstractItemModel::LayoutChangeHint hint) { Q_Q(QIdentityProxyModel); for (int i = 0; i < proxyIndexes.size(); ++i) { q->changePersistentIndex(proxyIndexes.at(i), q->mapFromSource(layoutChangePersistentIndexes.at(i))); } layoutChangePersistentIndexes.clear(); proxyIndexes.clear(); QList<QPersistentModelIndex> parents; parents.reserve(sourceParents.size()); foreach (const QPersistentModelIndex &parent, sourceParents) { if (!parent.isValid()) { parents << QPersistentModelIndex(); continue; } const QModelIndex mappedParent = q->mapFromSource(parent); Q_ASSERT(mappedParent.isValid()); parents << mappedParent; } q->layoutChanged(parents, hint); }
int ClipboardBrowser::removeIndexes(const QModelIndexList &indexes) { if ( indexes.isEmpty() ) return -1; Q_ASSERT(m_itemLoader); m_itemLoader->itemsRemovedByUser(indexes); QList<int> rows; rows.reserve( indexes.size() ); foreach (const QModelIndex &index, indexes) { if ( index.isValid() ) rows.append( index.row() ); } qSort( rows.begin(), rows.end(), qGreater<int>() ); ClipboardBrowser::Lock lock(this); foreach (int row, rows) { if ( !isRowHidden(row) ) m.removeRow(row); } return rows.last(); }
void QgsRasterShader::readXml( const QDomElement& elem ) { //only colorrampshader QDomElement colorRampShaderElem = elem.firstChildElement( QStringLiteral( "colorrampshader" ) ); if ( !colorRampShaderElem.isNull() ) { QgsColorRampShader* colorRampShader = new QgsColorRampShader(); colorRampShader->setColorRampType( colorRampShaderElem.attribute( QStringLiteral( "colorRampType" ), QStringLiteral( "INTERPOLATED" ) ) ); colorRampShader->setClip( colorRampShaderElem.attribute( QStringLiteral( "clip" ), QStringLiteral( "0" ) ) == QLatin1String( "1" ) ); QList<QgsColorRampShader::ColorRampItem> itemList; QDomElement itemElem; QString itemLabel; double itemValue; QColor itemColor; QDomNodeList itemNodeList = colorRampShaderElem.elementsByTagName( QStringLiteral( "item" ) ); itemList.reserve( itemNodeList.size() ); for ( int i = 0; i < itemNodeList.size(); ++i ) { itemElem = itemNodeList.at( i ).toElement(); itemValue = itemElem.attribute( QStringLiteral( "value" ) ).toDouble(); itemLabel = itemElem.attribute( QStringLiteral( "label" ) ); itemColor.setNamedColor( itemElem.attribute( QStringLiteral( "color" ) ) ); itemColor.setAlpha( itemElem.attribute( QStringLiteral( "alpha" ), QStringLiteral( "255" ) ).toInt() ); itemList.push_back( QgsColorRampShader::ColorRampItem( itemValue, itemColor, itemLabel ) ); } colorRampShader->setColorRampItemList( itemList ); setRasterShaderFunction( colorRampShader ); } }
QPair<QList<QNetworkRequest>, QStringList> Cache::createRequests(const QList<QUrl> &in, bool refreshAll) { QList<QUrl> urlsIn = in; QList<QNetworkRequest> requests; { QList<QUrl> urls = refreshAll ? in : getStaleUrls(in); requests.reserve(urls.size()); for (const auto url : urls) { urlsIn.removeAll(url); QNetworkRequest request(url); const auto entryIt = findEntry(url); if (entryIt != m_entries.end()) { const auto entry = *entryIt; // TODO add the md5 as a header } requests.append(request); } } QStringList localfiles; { // loop through all urls that didn't get made into network requests for (const auto url : urlsIn) { localfiles.append(absoluteFilename(*findEntry(url))); } } return qMakePair(requests, localfiles); }
/** * @brief cwRegionLoadTask::loadCave * @param protoCave * @param cave */ void cwRegionLoadTask::loadCave(const CavewhereProto::Cave& protoCave, cwCave *cave) { QString name = loadString(protoCave.name()); cwUnits::LengthUnit lengthUnit = (cwUnits::LengthUnit)protoCave.lengthunit(); cwUnits::LengthUnit depthUnit = (cwUnits::LengthUnit)protoCave.depthunit(); QList<cwTrip*> trips; trips.reserve(protoCave.trips_size()); cave->setName(name); cave->length()->setUnit(lengthUnit); cave->depth()->setUnit(depthUnit); for(int i = 0; i < protoCave.trips_size(); i++) { cwTrip* trip = new cwTrip(); loadTrip(protoCave.trips(i), trip); cave->addTrip(trip); } cwStationPositionLookup stationLookup = loadStationPositionLookup(protoCave.stationpositionlookup()); cave->setStationPositionLookup(stationLookup); if(protoCave.has_stationpositionlookup()) { cave->setStationPositionLookupStale(protoCave.stationpositionlookupstale()); } }
QList<Message> HistorySqlStorage::messagesBackTo(const Chat &chat, const QDateTime &datetime, int limit) { DatabaseMutex.lock(); QList<Message> result; QSqlQuery query(Database); // we want last *limit* messages, so we have to invert sorting here // it is reverted back manually below QString queryString = "SELECT chat, sender, content, send_time, receive_time, attributes FROM kadu_messages WHERE " + chatWhere(chat) + " AND datetime(receive_time) >= datetime(:date) ORDER BY receive_time DESC, rowid DESC LIMIT :limit"; query.prepare(queryString); query.bindValue(":chat", chat.uuid().toString()); query.bindValue(":date", datetime.toString(Qt::ISODate)); query.bindValue(":limit", limit); executeQuery(query); result = messagesFromQuery(query); DatabaseMutex.unlock(); // se comment above QList<Message> inverted; #if (QT_VERSION >= 0x040700) inverted.reserve(result.size()); #endif for (int i = result.size() - 1; i >= 0; --i) inverted.append(result.at(i)); return inverted; }
void DeclarativeTabStops::setTabStops(const QVariantList &tabStops) { if (tabStops == m_tabStops) return; m_tabStops = tabStops; QList<QWidget*> widgets; widgets.reserve(m_tabStops.count()); for (int i = 0; i < m_tabStops.count(); ++i) { QWidget *widget = qobject_cast<QWidget*>(m_tabStops[i].value<QObject*>()); if (widget != 0) { widgets << widget; } else { qmlInfo(this) << "TabStop at " << i << " is not a widget"; } } for (int i = 1; i < widgets.count(); ++i) { QWidget::setTabOrder(widgets[i - 1], widgets[i]); } emit tabStopsChanged(); }
std::shared_ptr<OsmAnd::ObfDataInterface> OsmAnd::ObfsCollection_P::obtainDataInterface() const { // Check if sources were invalidated if (_collectedSourcesInvalidated.loadAcquire() > 0) collectSources(); // Create ObfReaders from collected sources QList< std::shared_ptr<const ObfReader> > obfReaders; { QReadLocker scopedLocker(&_collectedSourcesLock); for(const auto& collectedSources : constOf(_collectedSources)) { obfReaders.reserve(obfReaders.size() + collectedSources.size()); for(const auto& obfFile : constOf(collectedSources)) { std::shared_ptr<const ObfReader> obfReader(new ObfReader(obfFile)); if (!obfReader->isOpened() || !obfReader->obtainInfo()) continue; obfReaders.push_back(qMove(obfReader)); } } } return std::shared_ptr<ObfDataInterface>(new ObfDataInterface(obfReaders)); }
static QList<T> fromStringList(const QStringList &list) { QList<T> ret; ret.reserve(list.size()); for (int i=0; i<list.size(); ++i) ret.push_back(T::fromString(list[i])); return ret; }
void QgsConfigureShortcutsDialog::populateActions() { QList<QAction*> actions = QgsShortcutsManager::instance()->listActions(); QList<QTreeWidgetItem *> items; items.reserve( actions.count() ); for ( int i = 0; i < actions.count(); ++i ) { QString actionText = actions[i]->text(); actionText.remove( '&' ); // remove the accelerator QStringList lst; lst << actionText << actions[i]->shortcut().toString(); QTreeWidgetItem* item = new QTreeWidgetItem( lst ); item->setIcon( 0, actions[i]->icon() ); item->setData( 0, Qt::UserRole, qVariantFromValue(( QObject* )actions[i] ) ); items.append( item ); } treeActions->addTopLevelItems( items ); // make sure everything's visible and sorted treeActions->resizeColumnToContents( 0 ); treeActions->sortItems( 0, Qt::AscendingOrder ); actionChanged( treeActions->currentItem(), NULL ); }
bool OpenCVAlgorithms::findSubImage(const QList<QImage> &sources, const QImage &target, MatchingPointList &matchingPoints, int matchPercentage, int maximumMatches, int downPyrs, int searchExpansion, AlgorithmMethod method) { mError = NoError; mErrorString.clear(); QList<cv::Mat> sourcesMat; sourcesMat.reserve(sources.size()); foreach(const QImage &source, sources) sourcesMat.append(toCVMat(source)); cv::Mat targetMat = toCVMat(target); if(!checkInputImages(sourcesMat, targetMat)) return false; matchingPoints = OpenCVAlgorithms::fastMatchTemplate(sourcesMat, targetMat, matchPercentage, maximumMatches, downPyrs, searchExpansion, method); return true; }
QList<TextShaper::TextRun> TextShaper::itemizeBiDi() { QList<TextRun> textRuns; UBiDi *obj = ubidi_open(); UErrorCode err = U_ZERO_ERROR; UBiDiLevel parLevel = UBIDI_LTR; ParagraphStyle style = m_story.paragraphStyle(m_firstChar); if (style.direction() == ParagraphStyle::RTL) parLevel = UBIDI_RTL; ubidi_setPara(obj, (const UChar*) m_text.utf16(), m_text.length(), parLevel, NULL, &err); if (U_SUCCESS(err)) { int32_t count = ubidi_countRuns(obj, &err); if (U_SUCCESS(err)) { textRuns.reserve(count); for (int32_t i = 0; i < count; i++) { int32_t start, length; UBiDiDirection dir = ubidi_getVisualRun(obj, i, &start, &length); textRuns.append(TextRun(start, length, dir)); } } } ubidi_close(obj); return textRuns; }
void QIdentityProxyModelPrivate::_q_sourceLayoutAboutToBeChanged(const QList<QPersistentModelIndex> &sourceParents, QAbstractItemModel::LayoutChangeHint hint) { Q_Q(QIdentityProxyModel); foreach(const QPersistentModelIndex &proxyPersistentIndex, q->persistentIndexList()) { proxyIndexes << proxyPersistentIndex; Q_ASSERT(proxyPersistentIndex.isValid()); const QPersistentModelIndex srcPersistentIndex = q->mapToSource(proxyPersistentIndex); Q_ASSERT(srcPersistentIndex.isValid()); layoutChangePersistentIndexes << srcPersistentIndex; } QList<QPersistentModelIndex> parents; parents.reserve(sourceParents.size()); foreach (const QPersistentModelIndex &parent, sourceParents) { if (!parent.isValid()) { parents << QPersistentModelIndex(); continue; } const QModelIndex mappedParent = q->mapFromSource(parent); Q_ASSERT(mappedParent.isValid()); parents << mappedParent; } q->layoutAboutToBeChanged(parents, hint); }
float ClusteringCoefficient::Compute() { QList<FeaturesComplexNetwork::Node> ids; ids.reserve(cn.getNumNodes()); for(FeaturesComplexNetwork::NodeIt it(cn); it != INVALID; ++it){ ids.append( it ); } std::random_shuffle(ids.begin(), ids.end()); QList<QList<FeaturesComplexNetwork::Node>> lists; lists.append(QList<FeaturesComplexNetwork::Node>()); int j=0; for(int i=0;i< ids.size()*ratio; i++){ lists.last().append(ids[i]); j++; if( j > 50 ){ j=0; lists.append(QList<FeaturesComplexNetwork::Node>()); } } FeaturesComplexNetwork::ArcMap<double> weights(cn); GraphUtilities::getWeights(cn, weights); GraphUtilities::normalizeWeights(cn,weights,weights); QThreadPool pool; pool.setMaxThreadCount(this->threads); for(auto &list : lists) { pool.start(new ClusteringCoefficientTask(this, cn, weights, list)); } pool.waitForDone(); return std::accumulate(ccs.begin(),ccs.end(),0.f, [](const float &a, const ClusteringCoefficient::NodeCC &b){return a+b.cc;})/ccs.size(); }
QList<int> SeasidePerson::phoneNumberTypes() const { const QList<QContactPhoneNumber> &numbers = mContact.details<QContactPhoneNumber>(); QList<int> types; types.reserve((numbers.length())); foreach(const QContactPhoneNumber &number, numbers) { if (number.contexts().contains(QContactDetail::ContextHome) && number.subTypes().contains(QContactPhoneNumber::SubTypeLandline)) { types.push_back(SeasidePerson::PhoneHomeType); } else if (number.contexts().contains(QContactDetail::ContextWork) && number.subTypes().contains(QContactPhoneNumber::SubTypeLandline)) { types.push_back(SeasidePerson::PhoneWorkType); } else if (number.contexts().contains(QContactDetail::ContextHome) && number.subTypes().contains(QContactPhoneNumber::SubTypeMobile)) { types.push_back(SeasidePerson::PhoneMobileType); } else if (number.contexts().contains(QContactDetail::ContextHome) && number.subTypes().contains(QContactPhoneNumber::SubTypeFax)) { types.push_back(SeasidePerson::PhoneFaxType); } else if (number.contexts().contains(QContactDetail::ContextHome) && number.subTypes().contains(QContactPhoneNumber::SubTypePager)) { types.push_back(SeasidePerson::PhonePagerType); } else { qWarning() << "Warning: Could not get phone type for '" << number.contexts() << "'"; } } return types; }
void CustomShortcutModel::loadShortcuts() { QList<CustomShortcut> actions; actions.reserve(_customizableActions.size()); QSettings cfg; cfg.beginGroup("settings/shortcuts"); for(CustomShortcut a : _customizableActions) { Q_ASSERT(!a.name.isEmpty()); if(cfg.contains(a.name)) a.currentShortcut = cfg.value(a.name).value<QKeySequence>(); if(a.currentShortcut.isEmpty()) a.currentShortcut = a.defaultShortcut; actions.append(a); } std::sort(actions.begin(), actions.end(), [](const CustomShortcut &a1, const CustomShortcut &a2) { return a1.title.compare(a2.title) < 0; } ); beginResetModel(); _shortcuts = actions; endResetModel(); }