void InventoryImpl::draw() { Vector2f pos = Vector2f(400, 300); int num_items = items.size(); float step_angle = (2.0f * math::pi) / static_cast<float>(num_items); for(int i = 0; i < int(items.size()); ++i) { const InventoryItem& item = items[(i+current_item) % items.size()]; Vector2f draw_pos = pos + Vector2f(128.0f, 0.0f).rotate(step_angle * static_cast<float>(i) - math::pi/2.0f + add_angle); if (i == 0 && moving == 0) { slothighlight.draw(draw_pos); Fonts::current()->vera20->draw_center(Vector2f(draw_pos.x, draw_pos.y - 64), item.name); } else { slot.draw(draw_pos); } item.sprite.draw(draw_pos - Vector2f(32,32)); } }
void InventoryImpl::draw() { Vector pos = Vector(400, 300); // View::current()->screen_Player::currently->get_pos(); int num_items = items.size(); float step_angle = (2*M_PI) / num_items; for(int i = 0; i < int(items.size()); ++i) { const InventoryItem& item = items[(i+current_item)%items.size()]; Vector draw_pos = pos + Vector(128, 0).rotate(step_angle * i - M_PI/2 + add_angle); if (i == 0 && moving == 0) { slothighlight.draw(draw_pos); Fonts::vera20->draw_center(draw_pos.x, draw_pos.y - 64, item.name); } else { slot.draw(draw_pos); } item.sprite.draw(draw_pos - Vector(32,32)); } }
void RowCollection<Group,Hash>::flushOneRowInBuffer(size_t rowId, Items const& items) { assert(rowId<_counts.size()); vector<boost::shared_ptr<ChunkIterator> > chunkIterators(_attributes.size()); try { if (! isLastChunkFull(rowId)) { // only get chunk iterators if there exists a non-full last chunk. getChunkIterators(chunkIterators, rowId); } for (size_t v=0; v<items.size(); ++v) { vector<Value> const& item = items[v]; if (isLastChunkFull(rowId)) { // when the last chunk was full, get the iterators here (right before append) getChunkIterators(chunkIterators, rowId); } for (size_t i=0; i<_attributes.size(); ++i) { chunkIterators[i]->writeItem(item[i]); } ++ _counts[rowId]; if (isLastChunkFull(rowId)) { // after append, flush and clear the chunk iterators if the last chunk becomes full for (size_t i=0; i<_attributes.size(); ++i) { chunkIterators[i]->flush(); chunkIterators[i].reset(); } } else { for (size_t i=0; i<_attributes.size(); ++i) { ++ (*chunkIterators[i]); } } } if (items.size()>0 && !isLastChunkFull(rowId)) { assert(chunkIterators[0]); for (size_t i=0; i<_attributes.size(); ++i) { chunkIterators[i]->flush(); chunkIterators[i].reset(); } } else { assert(! chunkIterators[0]); } } catch (std::exception& e) { LOG4CXX_DEBUG(logger, "[RowCollection] std::exception in RowIterator::appendItems(): " << e.what()); throw; } catch (...) { LOG4CXX_DEBUG(logger, "[RowCollection] (...) exception in RowIterator::appendItem()" ); throw; } }
void Search::UpdateItemCounts(const Items &items) { unfiltered_item_count_ = items.size(); filtered_item_count_total_ = 0; for (auto &item : items_) filtered_item_count_total_ += item->count(); }
void InventoryImpl::update(float delta, const Controller& controller) { float step_angle = (2.0f * math::pi) / static_cast<float>(items.size()); if (fabsf(add_angle) > step_angle) { if (moving == 1) decr_current_item(); else if (moving == -1) incr_current_item(); moving = 0; add_angle = 0; } if (controller.get_axis_state(X_AXIS) < -0.5f) { if (moving == 1) { add_angle = -step_angle + add_angle; decr_current_item(); } moving = -1; } else if (controller.get_axis_state(X_AXIS) > 0.5f) { if (moving == -1) { add_angle = step_angle + add_angle; incr_current_item(); } moving = 1; } if (moving == -1) { add_angle -= 3 * delta; } else if (moving == 1) { add_angle += 3 * delta; } if (moving == 0) { if (controller.button_was_pressed(OK_BUTTON) || controller.button_was_pressed(CANCEL_BUTTON) || controller.button_was_pressed(INVENTORY_BUTTON)) { GameSession::current()->set_control_state(GameSession::GAME); } } }
void Client::processPersistentRequests(_Store& store) { // create a typedef for the vector holding the correct type of items typedef std::vector<typename _Store::Item> Items; // get the items that need to be reconstructed Items items = store.getBadItems(); if (items.size() > 0) logger_->debug("A total of %d persistent requests need to be re-processed", items.size()); // loop through the items and process them // (We don't have to care about the Status result of the processRequest function, // since processPersistentRequests() is called automatically by a thread, and this // thread doesn't perform any actions in case of failures.) for (typename Items::iterator it = items.begin(); it != items.end(); ++it) processRequest<typename _Store::ServiceType>( it->request, it->badTargetsMask, it->result); }
// Algorithm to calculate the edit operations to allow //_ replaceing items without model reset inline void replace(const Items &newItems, int from = 0) { using namespace kamd::utils::member_matcher; #if 0 QDBG << "===\nOld items {"; for (const auto& item: m_items) { QDBG << item; } QDBG << "}"; QDBG << "New items to be added at " << from << " {"; for (const auto& item: newItems) { QDBG << item; } QDBG << "}"; #endif // Based on 'The string to string correction problem // with block moves' paper by Walter F. Tichy // // In essence, it goes like this: // // Take the first element from the new list, and try to find // it in the old one. If you can not find it, it is a new item // item - send the 'inserted' event. // If you did find it, test whether the following items also // match. This detects blocks of items that have moved. // // In this example, we find 'b', and then detect the rest of the // moved block 'b' 'c' 'd' // // Old items: a[b c d]e f g // ^ // / // New items: [b c d]a f g // // After processing one block, just repeat until the end of the // new list is reached. // // Then remove all remaining elements from the old list. // // The main addition here compared to the original papers is that // our 'strings' can not hold two instances of the same element, // and that we support updating from arbitrary position. auto newBlockStart = newItems.cbegin(); // How many items should we add? // This should remove the need for post-replace-trimming // in the case where somebody called this with too much new items. const int maxToReplace = m_countLimit - from; if (maxToReplace <= 0) return; const auto newItemsEnd = newItems.size() <= maxToReplace ? newItems.cend() : newItems.cbegin() + maxToReplace; // Finding the blocks until we reach the end of the newItems list // // from = 4 // Old items: X Y Z U a b c d e f g // ^ oldBlockStart points to the first element // of the currently processed block in the old list // // New items: _ _ _ _ b c d a f g // ^ newBlockStartIndex is the index of the first // element of the block that is currently being // processed (with 'from' offset) while (newBlockStart != newItemsEnd) { const int newBlockStartIndex = from + std::distance(newItems.cbegin(), newBlockStart); const auto oldBlockStart = std::find_if( m_items.begin() + from, m_items.end(), member(&ResultSet::Result::resource) == newBlockStart->resource()); if (oldBlockStart == m_items.end()) { // This item was not found in the old cache, so we are // inserting a new item at the same position it had in // the newItems array d->q->beginInsertRows(QModelIndex(), newBlockStartIndex, newBlockStartIndex); m_items.insert(newBlockStartIndex, *newBlockStart); d->q->endInsertRows(); // This block contained only one item, move on to find // the next block - it starts from the next item ++newBlockStart; } else { // We are searching for a block of matching items. // This is a reimplementation of std::mismatch that // accepts two complete ranges that is available only // since C++14, so we can not use it. auto newBlockEnd = newBlockStart; auto oldBlockEnd = oldBlockStart; while (newBlockEnd != newItemsEnd && oldBlockEnd != m_items.end() && newBlockEnd->resource() == oldBlockEnd->resource()) { ++newBlockEnd; ++oldBlockEnd; } // We have found matching blocks // [newBlockStart, newBlockEnd) and [oldBlockStart, newBlockEnd) const int oldBlockStartIndex = std::distance(m_items.begin() + from, oldBlockStart); const int blockSize = std::distance(oldBlockStart, oldBlockEnd); if (oldBlockStartIndex != newBlockStartIndex) { // If these blocks do not have the same start, // we need to send the move event. // Note: If there is a crash here, it means we // are getting a bad query which has duplicate // results d->q->beginMoveRows(QModelIndex(), oldBlockStartIndex, oldBlockStartIndex + blockSize - 1, QModelIndex(), newBlockStartIndex); // Moving the items from the old location to the new one kamd::utils::slide( oldBlockStart, oldBlockEnd, m_items.begin() + newBlockStartIndex); d->q->endMoveRows(); } // Skip all the items in this block, and continue with // the search newBlockStart = newBlockEnd; } } // We have avoided the need for trimming for the most part, // but if the newItems list was shorter than needed, we still // need to trim the rest. trim(from + newItems.size()); // Check whether we got an item representing a non-existent file, // if so, schedule its removal from the database for (const auto &item: newItems) { if (item.resource().startsWith('/') && !QFile(item.resource()).exists()) { d->q->forgetResource(item.resource()); } } }
/* static */ void Module_DMAP::generic_worker_single_thr(Module_DMAP * search, int id) { Mask * sequences; int read_seq; vector<Mask> printable_solutions; Transmitting_Result received; if (search->my_rank == 0) { sequences = new Mask[SEQUENCES_FOR_BLOCK]; read_seq = read_sequences(search->input_file1, SEQUENCES_FOR_BLOCK, sequences, search->fastqformat, search->gui_output); } else { received = search->receive_from_previous(id); sequences = received.first; read_seq = received.second; } while (read_seq != 0) { Items solutions; //ItemsGapped solutions_gapped; t_errors calculated_errors; for (int i = 0; i < read_seq; i++) { Mask & s = sequences[i]; if (search->my_rank == 0 and search->trim) { // check_routine(sequences[i], 0); s.quality_trimming_MOTT(search->min_phred_value_MOTT,search->min_mean_quality,search->min_size); } if (s.status_discarded()) { if (s.status_low_complexity()) s.low_complexity =true; //s.set_type(low_complexity); else s.low_quality = true; //s.set_type(quality_discarded); printable_solutions.push_back(s); continue; } if (search->auto_errors) calculated_errors = round((double)s.get_good_length() / search->errors_rate); else calculated_errors = search->common_errors_allowed; if (search->my_rank != 0 and s.algn > 0 and s.NM < calculated_errors) calculated_errors = s.NM; t_errors count = 0; for (t_pattern_length i = s.get_good_region_start()-1; (i < s.get_good_region_stop()) and (count <= calculated_errors); i++) if (s.sequence[i] == 'N' or s.sequence[i] == 'n') count++; if (count > calculated_errors) { //s.set_type(alignments_not_found); printable_solutions.push_back(s); continue; } /** ALIGNMENT **/ solutions.clear(); if (search->my_rank == 0 and search->contamination_check) { search->CR.search(s.get_good_sequence(),solutions,calculated_errors); if (solutions.size() > 0) s.contaminated = true; } if (not s.contaminated) search->H.search(s.get_good_sequence(),solutions,calculated_errors); if (solutions.size() == 0) { /** Try gapped **/ /* solutions_gapped.clear(); if (search->gap) search->H.search_gapped(s.get_good_sequence(),solutions_gapped,search->seed_sizes,search->seed_errors,calculated_errors,search->max_gap); */ /* if (solutions_gapped.size() == 0) {// size 0 means no alignment found */ //s.set_type(alignments_not_found); printable_solutions.push_back(s); continue; /* } else { if (not search->printAll) { Random_Choice_Result r; bool improved = (s.NM + s.NM_gap) > (solutions_gapped.at(0).errors1 + solutions_gapped.at(0).errors2); if (improved) r = Search_MPI::random_choice_from_previous(0,solutions_gapped.size()); else r = Search_MPI::random_choice_from_previous(s.algn,solutions_gapped.size()); if (not improved and r.first) { // take the previous solution s.algn += solutions_gapped.size(); } else { // update solution const ResultItemGapped & HM = solutions_gapped.at(r.second); s.globalPosition = HM.GlobalPosition1; if (improved) s.algn = solutions_gapped.size(); else s.algn += solutions_gapped.size(); s.HI = 1; s.IH = 1; s.primary = true; s.strand = HM.strand; s.NM = HM.errors1; s.NM_gap = HM.errors2; s.contig = HM.contig; s.position = HM.GlobalPosition1 - search->H.globaltolocal.startPositions[HM.contig] + 1 ; s.position_gap = HM.GlobalPosition2 - search->H.globaltolocal.startPositions[HM.contig] + 1 ; s.length1_gap = HM.length1; s.length2_gap = HM.length2; s.contig = search->contig_conversion.convert(s.contig); } printable_solutions.push_back(s); } else { // printALL */ /* unsigned int processed=0; unsigned int alignments; (search->toBePrinted < solutions_gapped.size()) ? alignments = search->toBePrinted : alignments = solutions_gapped.size() ; while(processed < alignments) { const ResultItemGapped & HM = solutions_gapped.at(processed); s.globalPosition = HM.GlobalPosition1; s.algn = alignments; s.HI =1; s.IH =1; (processed == 0 ) ? s.primary = true : s.primary = false; s.strand = HM.strand; s.NM = HM.errors1; s.NM_gap = HM.errors2; s.contig = HM.contig ; s.position = HM.GlobalPosition1 - search->H.globaltolocal.startPositions[HM.contig] + 1 ; s.position_gap = HM.GlobalPosition2 - search->H.globaltolocal.startPositions[HM.contig] + 1 ; s.length1_gap = HM.length1; s.length2_gap = HM.length2; s.contaminated = contaminated; printable_solutions.push_back(s); processed++; } */ /* ERROR_CHANNEL << "--print-all option not implemented yet!" << endl; exit(3); } } */ } else if (not search->printAll) { sort(solutions.begin(), solutions.end(), ResultItem::less()); // sort solutions solutions.erase(unique(solutions.begin(), solutions.end(), ResultItem::equal()), solutions.end()); Random_Choice_Result r; bool improved = (s.NM + s.NM_gap) > (solutions.at(0).errors); if (improved) r = Module_DMAP::random_choice_from_previous(0,solutions.size()); else { r = Module_DMAP::random_choice_from_previous(s.algn,solutions.size()); s.algn += solutions.size(); } if (not r.first) { const ResultItem & HM = solutions.at(r.second); s.HI = 1; s.IH = 1; s.primary = true; s.globalPosition = HM.globalPosition; s.strand = HM.strand; s.NM = HM.errors; s.NM_gap = 0; if ((search->my_rank == 0) and s.contaminated) { s.contig = search->CR.globalToLocal.searchContig(HM.globalPosition); // find the contig/scaffold s.position = HM.globalPosition - search->CR.globalToLocal.startPositions[s.contig] + 1; s.contig = search->contig_conversion.convert(s.contig); } else { s.contig = search->H.globalToLocal.searchContig(HM.globalPosition); // find the contig/scaffold s.position = HM.globalPosition - search->H.globalToLocal.startPositions[s.contig] + 1; s.contig = search->contig_conversion.convert(s.contig); } } printable_solutions.push_back(s); continue; } else { // printAll /* // memorize all printable solutions sort(solutions.begin(), solutions.end(), ResultItem::less()); // sort solutions solutions.erase(unique(solutions.begin(), solutions.end(), ResultItem::equal()), solutions.end()); unsigned int processed=0; unsigned int alignments; (search->toBePrinted < solutions.size()) ? alignments = search->toBePrinted : alignments = solutions.size() ; while(processed < alignments) { // while I print enough solution or there are no more solutions const ResultItem & HM = solutions.at(processed); s.globalPosition = HM.GlobalPosition; s.algn = solutions.size(); s.IH = alignments; s.HI = processed+1; (processed == 0 ) ? s.primary = true : s.primary = false; s.strand = HM.strand; s.NM = HM.errors; if (contaminated) { s.contig = search->CR.globaltolocal.searchContig(HM.GlobalPosition); // find the contig/scaffold s.position = HM.GlobalPosition - search->CR.globaltolocal.startPositions[s.contig] + 1; } else { s.contig = search->H.globaltolocal.searchContig(HM.GlobalPosition); // find the contig/scaffold s.position = HM.GlobalPosition - search->H.globaltolocal.startPositions[s.contig] + 1; } s.contaminated = contaminated; printable_solutions.push_back(s); } */ ERROR_CHANNEL << "--print-all option not implemented yet!" << endl; exit(3); } } if (search->my_rank == (search->nprocs-1)) { // now print all for(unsigned int i=0; i < printable_solutions.size(); i++) search->output_samfile.print_output(printable_solutions.at(i)); search->processed += read_seq; } else // send data to next node search->send_to_next(printable_solutions,id); delete [] sequences; printable_solutions.clear(); if (search->my_rank == 0) { sequences = new Mask[SEQUENCES_FOR_BLOCK]; read_seq = read_sequences(search->input_file1, SEQUENCES_FOR_BLOCK, sequences, search->fastqformat, search->gui_output); if (read_seq == 0) delete [] sequences; } else { received = search->receive_from_previous(id); sequences = received.first; read_seq = received.second; } } }
void decr_current_item() { if (current_item == 0) current_item = items.size() - 1; else current_item -= 1; }
void incr_current_item() { if (current_item == int(items.size()) - 1) current_item = 0; else current_item += 1; }
int OTWS_Wordseg_x(otws_t handle, const string& sent, vector<string>& words) { OTWS_Engine *engine = reinterpret_cast<OTWS_Engine *>(handle); words.clear(); RawSentence *tag_sent = new TagSent(); vector<string> chars; int numChars = UTF::getCharactersFromUTF8String(sent, &chars); // something for debug. cerr << "TOKEN: "; for (int i = 0; i < numChars; ++ i) { cerr << chars[i] << " | "; tag_sent->append(new TagItem(chars[i], "X")); } cerr << endl; Instance *inst = (engine)->extractor->extract(tag_sent, false); Items *items = inst->items(); Labels* labels = engine->decoder->decode(inst, engine->model->getParameter("PARAMETER"))->best(); Alphabet *labelsDict = engine->model->getAlphabet("LABELS"); // something for debug. for (int i = 0; i < labels->size(); ++ i) { cerr << labelsDict->rlookup(labels->at(i)) << "(" << labels->at(i) << ") "; } cerr << "| label size: " << labels->size() << endl; string tag; string word; for (int i = 0; i < items->size(); ) { tag = labelsDict->rlookup(labels->at(i)); if ("S" == tag) { word = chars[i]; words.push_back(word); ++ i; } else if ("B" == tag) { word = ""; while ("E" != tag && i < items->size()){ word = word + chars[i]; tag = labelsDict->rlookup(labels->at(i)); ++ i; } words.push_back(word); } else { cerr << "Exception asserted." << endl; words.clear(); return -1; } } return words.size(); }
size_t items_size() { return items_.size(); }
QList<ShopTemplateManager::ShopTemplateSection> ShopTemplateManager::FetchFromItemsKey(const QString &key, const Items &items, QHash<QString, QString> *options) { QList<ShopTemplateManager::ShopTemplateSection> result; if (items.size() > 0){ Items matchingItems; bool includeNoBuyouts = options->contains("include.ignored"); ShopTemplateContainType containType = CONTAIN_TYPE_NONE; if (key == "everything") { matchingItems = items; } else if (key.startsWith("stash:")) { int index = key.indexOf(":"); QString name = (index + 1 >= key.length()) ? "" : key.mid(index + 1); if (!name.isEmpty()) { for (const std::shared_ptr<Item> &item : items) { if (QString::fromStdString(item->location().GetLabel()).compare(name, Qt::CaseInsensitive) == 0) { matchingItems.push_back(item); } } } } else { Items pool = items; QStringList keyParts = key.split("+", QString::SkipEmptyParts); for (QString part : keyParts) { if (templateMatchers.contains(part)) { matchingItems = FindMatchingItems(pool, part); } else { // todo(novynn): phase these out? Prefer {Normal+Helmet} over {NormalHelmet} bool matchedRarity = false; const QStringList rarities = {"normal", "magic", "rare", "unique"}; for (QString rarity : rarities) { if (part.startsWith(rarity)) { QString type = part.mid(rarity.length()); matchingItems = FindMatchingItems(pool, rarity); matchingItems = FindMatchingItems(matchingItems, type); matchedRarity = true; } } if (matchedRarity) continue; if (part.endsWith("gems")) { if (part == "gems" || part == "allgems") { matchingItems = FindMatchingItems(pool, "gems"); } else { const QStringList gemTypes = {"AoE", "Attack", "Aura", "Bow", "Cast", "Chaining", "Chaos", "Cold", "Curse", "Duration", "Fire", "Lightning", "Melee", "Mine", "Minion", "Movement", "Projectile", "Spell", "Totem", "Trap", "Support"}; for (QString gemType : gemTypes) { if (!part.startsWith(gemType, Qt::CaseInsensitive)) continue; // This will never just be first key (?) QString firstKey = gemType.toLower() + "gems"; matchingItems = FindMatchingItems(pool, firstKey); if (part != firstKey) { // supportlightninggems QString secondKey = part.mid(gemType.length()); matchingItems = FindMatchingItems(matchingItems, secondKey); } } } } } pool = matchingItems; } } // Only select items from your stash unless specified if (!options->contains("include.character")) { matchingItems = Items::fromStdVector( from(matchingItems.toStdVector()) .where([](const std::shared_ptr<Item> item) { return item->location().type() == ItemLocationType::STASH; }) .toVector() ); } if (matchingItems.size() == 0) return result; if (containType == CONTAIN_TYPE_NONE && options->contains("wrap")) containType = CONTAIN_TYPE_WRAP; if (containType == CONTAIN_TYPE_NONE && options->contains("group")) containType = CONTAIN_TYPE_GROUP; switch (containType) { case (CONTAIN_TYPE_WRAP): { QString header = "Items"; Buyout buyout = {}; if (options->contains("header")) { header = options->value("header"); } const std::shared_ptr<Item> first = matchingItems.first(); if (parent_->buyout_manager().Exists(*first)) buyout = parent_->buyout_manager().Get(*first); bool sameBuyout = from(matchingItems.toStdVector()).all([this, buyout](const std::shared_ptr<Item> item) { Buyout thisBuyout = {}; if (parent_->buyout_manager().Exists(*item)) thisBuyout = parent_->buyout_manager().Get(*item); return BuyoutManager::Equal(thisBuyout, buyout); }); if (sameBuyout) { header += BuyoutManager::Generate(buyout); } QStringList temp = WriteItems(matchingItems, !sameBuyout, includeNoBuyouts); if (!temp.isEmpty()) { result << ShopTemplateSection(temp, SECTION_TYPE_SPOILER, header); } break; } case CONTAIN_TYPE_GROUP: { QMultiMap<QString, std::shared_ptr<Item>> itemsMap; for (auto &item : matchingItems) { Buyout b = {}; if (parent_->buyout_manager().Exists(*item)) b = parent_->buyout_manager().Get(*item); itemsMap.insert(BuyoutManager::Generate(b), item); } for (QString buyout : itemsMap.uniqueKeys()) { Items itemList = itemsMap.values(buyout).toVector(); if (itemList.size() == 0) continue; QString header = buyout; if (header.isEmpty()) header = "Offers Accepted"; QStringList temp = WriteItems(itemList, false, includeNoBuyouts); if (temp.isEmpty()) continue; result << ShopTemplateSection(temp, SECTION_TYPE_SPOILER, header); } break; } default: { QStringList temp = WriteItems(matchingItems, true, includeNoBuyouts); result << ShopTemplateSection(temp, SECTION_TYPE_NONE); break; } } } return result; }
size_t FillTreeClass<T>::setTreeInternal(T& _safelocker, Items& _items, const ::profiler::timestamp_t& _beginTime, const ::profiler::BlocksTree::children_t& _children, EasyTreeWidgetItem* _parent, EasyTreeWidgetItem* _frame, EasyTreeWidgetItem* _thread, ::profiler::timestamp_t _left, ::profiler::timestamp_t _right, bool _strict, ::profiler::timestamp_t& _duration, bool _colorizeRows) { size_t total_items = 0; for (auto child_index : _children) { if (_safelocker.interrupted()) break; auto& gui_block = easyBlock(child_index); const auto& child = gui_block.tree; const auto startTime = child.node->begin(); const auto endTime = child.node->end(); const auto duration = endTime - startTime; _duration += duration; if (startTime > _right || endTime < _left) { continue; } auto item = new EasyTreeWidgetItem(child_index, _parent); auto name = *child.node->name() != 0 ? child.node->name() : easyDescriptor(child.node->id()).name(); item->setText(COL_NAME, ::profiler_gui::toUnicode(name)); item->setTimeSmart(COL_DURATION, duration); item->setTimeMs(COL_BEGIN, startTime - _beginTime); item->setTimeMs(COL_END, endTime - _beginTime); item->setData(COL_PERCENT_SUM_PER_THREAD, Qt::UserRole, 0); if (child.per_thread_stats != nullptr) // if there is per_thread_stats then there are other stats also { const auto& per_thread_stats = child.per_thread_stats; const auto& per_parent_stats = child.per_parent_stats; const auto& per_frame_stats = child.per_frame_stats; auto percentage = duration == 0 ? 0 : ::profiler_gui::percent(duration, _parent->duration()); auto percentage_sum = ::profiler_gui::percent(per_parent_stats->total_duration, _parent->duration()); item->setData(COL_PERCENT_PER_PARENT, Qt::UserRole, percentage); item->setText(COL_PERCENT_PER_PARENT, QString::number(percentage)); item->setData(COL_PERCENT_SUM_PER_PARENT, Qt::UserRole, percentage_sum); item->setText(COL_PERCENT_SUM_PER_PARENT, QString::number(percentage_sum)); if (_frame != nullptr) { if (_parent != _frame) { percentage = duration == 0 ? 0 : ::profiler_gui::percent(duration, _frame->duration()); percentage_sum = ::profiler_gui::percent(per_frame_stats->total_duration, _frame->duration()); } item->setData(COL_PERCENT_PER_FRAME, Qt::UserRole, percentage); item->setText(COL_PERCENT_PER_FRAME, QString::number(percentage)); item->setData(COL_PERCENT_SUM_PER_FRAME, Qt::UserRole, percentage_sum); item->setText(COL_PERCENT_SUM_PER_FRAME, QString::number(percentage_sum)); } else { item->setData(COL_PERCENT_PER_FRAME, Qt::UserRole, 0); item->setData(COL_PERCENT_SUM_PER_FRAME, Qt::UserRole, 0); if (_thread) { auto percentage_per_thread = ::profiler_gui::percent(duration, _thread->selfDuration()); item->setData(COL_PERCENT_PER_PARENT, Qt::UserRole, percentage_per_thread); item->setText(COL_PERCENT_PER_PARENT, QString::number(percentage_per_thread)); } else { item->setData(COL_PERCENT_PER_PARENT, Qt::UserRole, 0); } } if (per_thread_stats->calls_number > 1 || !EASY_GLOBALS.display_only_relevant_stats) { item->setTimeSmart(COL_MIN_PER_THREAD, per_thread_stats->min_duration, "min "); item->setTimeSmart(COL_MAX_PER_THREAD, per_thread_stats->max_duration, "max "); item->setTimeSmart(COL_AVERAGE_PER_THREAD, per_thread_stats->average_duration()); item->setTimeSmart(COL_DURATION_SUM_PER_THREAD, per_thread_stats->total_duration); } item->setData(COL_NCALLS_PER_THREAD, Qt::UserRole, per_thread_stats->calls_number); item->setText(COL_NCALLS_PER_THREAD, QString::number(per_thread_stats->calls_number)); if (_thread) { auto percentage_per_thread = ::profiler_gui::percent(per_thread_stats->total_duration, _thread->selfDuration()); item->setData(COL_PERCENT_SUM_PER_THREAD, Qt::UserRole, percentage_per_thread); item->setText(COL_PERCENT_SUM_PER_THREAD, QString::number(percentage_per_thread)); } if (per_parent_stats->calls_number > 1 || !EASY_GLOBALS.display_only_relevant_stats) { item->setTimeSmart(COL_MIN_PER_PARENT, per_parent_stats->min_duration, "min "); item->setTimeSmart(COL_MAX_PER_PARENT, per_parent_stats->max_duration, "max "); item->setTimeSmart(COL_AVERAGE_PER_PARENT, per_parent_stats->average_duration()); item->setTimeSmart(COL_DURATION_SUM_PER_PARENT, per_parent_stats->total_duration); } item->setData(COL_NCALLS_PER_PARENT, Qt::UserRole, per_parent_stats->calls_number); item->setText(COL_NCALLS_PER_PARENT, QString::number(per_parent_stats->calls_number)); if (per_frame_stats->calls_number > 1 || !EASY_GLOBALS.display_only_relevant_stats) { item->setTimeSmart(COL_MIN_PER_FRAME, per_frame_stats->min_duration, "min "); item->setTimeSmart(COL_MAX_PER_FRAME, per_frame_stats->max_duration, "max "); item->setTimeSmart(COL_AVERAGE_PER_FRAME, per_frame_stats->average_duration()); item->setTimeSmart(COL_DURATION_SUM_PER_FRAME, per_frame_stats->total_duration); } item->setData(COL_NCALLS_PER_FRAME, Qt::UserRole, per_frame_stats->calls_number); item->setText(COL_NCALLS_PER_FRAME, QString::number(per_frame_stats->calls_number)); } else { if (_frame == nullptr && _thread != nullptr) { auto percentage_per_thread = ::profiler_gui::percent(duration, _thread->selfDuration()); item->setData(COL_PERCENT_PER_PARENT, Qt::UserRole, percentage_per_thread); item->setText(COL_PERCENT_PER_PARENT, QString::number(percentage_per_thread)); } else { item->setData(COL_PERCENT_PER_PARENT, Qt::UserRole, 0); } item->setData(COL_PERCENT_SUM_PER_PARENT, Qt::UserRole, 0); item->setData(COL_PERCENT_SUM_PER_THREAD, Qt::UserRole, 0); } const auto color = easyDescriptor(child.node->id()).color(); //const auto bgColor = ::profiler_gui::fromProfilerRgb(::profiler::colors::get_red(color), ::profiler::colors::get_green(color), ::profiler::colors::get_blue(color)); const auto fgColor = ::profiler_gui::textColorForRgb(color);// 0x00ffffff - bgColor; item->setBackgroundColor(color); item->setTextColor(fgColor); auto item_index = static_cast<uint32_t>(_items.size()); _items.push_back(item); size_t children_items_number = 0; ::profiler::timestamp_t children_duration = 0; if (!child.children.empty()) { children_items_number = FillTreeClass<T>::setTreeInternal(_safelocker, _items, _beginTime, child.children, item, _frame ? _frame : item, _thread, _left, _right, _strict, children_duration, _colorizeRows); if (_safelocker.interrupted()) break; } int percentage = 100; auto self_duration = duration - children_duration; if (children_duration > 0 && duration > 0) { percentage = ::profiler_gui::percent(self_duration, duration); } item->setTimeSmart(COL_SELF_DURATION, self_duration); item->setData(COL_SELF_DURATION_PERCENT, Qt::UserRole, percentage); item->setText(COL_SELF_DURATION_PERCENT, QString::number(percentage)); if (children_items_number > 0 || !_strict || (startTime >= _left && endTime <= _right)) { total_items += children_items_number + 1; gui_block.tree_item = item_index; if (_colorizeRows) item->colorize(_colorizeRows); if (gui_block.expanded) item->setExpanded(true); } else { _items.pop_back(); delete item; } } return total_items; }
void FillTreeClass<T>::setTreeInternal2(T& _safelocker, Items& _items, ThreadedItems& _topLevelItems, const ::profiler::timestamp_t& _beginTime, const ::profiler_gui::TreeBlocks& _blocks, ::profiler::timestamp_t _left, ::profiler::timestamp_t _right, bool _strict, bool _colorizeRows) { //size_t blocksNumber = 0; //for (const auto& block : _blocks) // blocksNumber += calculateTotalChildrenNumber(*block.tree); // //blocksNumber += block.tree->total_children_number; //m_items.reserve(blocksNumber + _blocks.size()); // blocksNumber does not include root blocks RootsMap threadsMap; const auto u_thread = ::profiler_gui::toUnicode("thread"); int i = 0, total = static_cast<int>(_blocks.size()); //const QSignalBlocker b(this); for (const auto& block : _blocks) { if (_safelocker.interrupted()) break; auto& gui_block = easyBlock(block.tree); const auto startTime = gui_block.tree.node->begin(); const auto endTime = gui_block.tree.node->end(); if (startTime > _right || endTime < _left) { _safelocker.setProgress((90 * ++i) / total); continue; } ::profiler::timestamp_t duration = 0; EasyTreeWidgetItem* thread_item = nullptr; auto thread_item_it = threadsMap.find(block.root->thread_id); if (thread_item_it != threadsMap.end()) { thread_item = thread_item_it->second; } else { thread_item = new EasyTreeWidgetItem(); QString threadName; if (block.root->got_name()) { QString rootname(::profiler_gui::toUnicode(block.root->name())); if (rootname.contains(u_thread, Qt::CaseInsensitive)) threadName = ::std::move(QString("%1 %2").arg(rootname).arg(block.root->thread_id)); else threadName = ::std::move(QString("%1 Thread %2").arg(rootname).arg(block.root->thread_id)); } else { threadName = ::std::move(QString("Thread %1").arg(block.root->thread_id)); } thread_item->setText(COL_NAME, threadName); if (!block.root->children.empty()) duration = blocksTree(block.root->children.back()).node->end() - blocksTree(block.root->children.front()).node->begin(); thread_item->setTimeSmart(COL_DURATION, duration); thread_item->setBackgroundColor(::profiler_gui::SELECTED_THREAD_BACKGROUND); thread_item->setTextColor(::profiler_gui::SELECTED_THREAD_FOREGROUND); // Sum of all children durations: thread_item->setTimeSmart(COL_SELF_DURATION, block.root->active_time); threadsMap.insert(::std::make_pair(block.root->thread_id, thread_item)); } auto item = new EasyTreeWidgetItem(block.tree, thread_item); duration = endTime - startTime; auto name = *gui_block.tree.node->name() != 0 ? gui_block.tree.node->name() : easyDescriptor(gui_block.tree.node->id()).name(); item->setText(COL_NAME, ::profiler_gui::toUnicode(name)); item->setTimeSmart(COL_DURATION, duration); item->setTimeMs(COL_BEGIN, startTime - _beginTime); item->setTimeMs(COL_END, endTime - _beginTime); item->setData(COL_PERCENT_PER_FRAME, Qt::UserRole, 0); auto percentage_per_thread = ::profiler_gui::percent(duration, block.root->active_time); item->setData(COL_PERCENT_PER_PARENT, Qt::UserRole, percentage_per_thread); item->setText(COL_PERCENT_PER_PARENT, QString::number(percentage_per_thread)); if (gui_block.tree.per_thread_stats != nullptr) // if there is per_thread_stats then there are other stats also { const auto& per_thread_stats = gui_block.tree.per_thread_stats; const auto& per_parent_stats = gui_block.tree.per_parent_stats; const auto& per_frame_stats = gui_block.tree.per_frame_stats; if (per_thread_stats->calls_number > 1 || !EASY_GLOBALS.display_only_relevant_stats) { item->setTimeSmart(COL_MIN_PER_THREAD, per_thread_stats->min_duration, "min "); item->setTimeSmart(COL_MAX_PER_THREAD, per_thread_stats->max_duration, "max "); item->setTimeSmart(COL_AVERAGE_PER_THREAD, per_thread_stats->average_duration()); item->setTimeSmart(COL_DURATION_SUM_PER_THREAD, per_thread_stats->total_duration); } item->setData(COL_NCALLS_PER_THREAD, Qt::UserRole, per_thread_stats->calls_number); item->setText(COL_NCALLS_PER_THREAD, QString::number(per_thread_stats->calls_number)); percentage_per_thread = ::profiler_gui::percent(per_thread_stats->total_duration, block.root->active_time); item->setData(COL_PERCENT_SUM_PER_THREAD, Qt::UserRole, percentage_per_thread); item->setText(COL_PERCENT_SUM_PER_THREAD, QString::number(percentage_per_thread)); if (per_parent_stats->calls_number > 1 || !EASY_GLOBALS.display_only_relevant_stats) { item->setTimeSmart(COL_MIN_PER_PARENT, per_parent_stats->min_duration, "min "); item->setTimeSmart(COL_MAX_PER_PARENT, per_parent_stats->max_duration, "max "); item->setTimeSmart(COL_AVERAGE_PER_PARENT, per_parent_stats->average_duration()); item->setTimeSmart(COL_DURATION_SUM_PER_PARENT, per_parent_stats->total_duration); } item->setData(COL_NCALLS_PER_PARENT, Qt::UserRole, per_parent_stats->calls_number); item->setText(COL_NCALLS_PER_PARENT, QString::number(per_parent_stats->calls_number)); if (per_frame_stats->calls_number > 1 || !EASY_GLOBALS.display_only_relevant_stats) { item->setTimeSmart(COL_MIN_PER_FRAME, per_frame_stats->min_duration, "min "); item->setTimeSmart(COL_MAX_PER_FRAME, per_frame_stats->max_duration, "max "); item->setTimeSmart(COL_AVERAGE_PER_FRAME, per_frame_stats->average_duration()); item->setTimeSmart(COL_DURATION_SUM_PER_FRAME, per_frame_stats->total_duration); } item->setData(COL_NCALLS_PER_FRAME, Qt::UserRole, per_frame_stats->calls_number); item->setText(COL_NCALLS_PER_FRAME, QString::number(per_frame_stats->calls_number)); } else { item->setData(COL_PERCENT_SUM_PER_THREAD, Qt::UserRole, 0); item->setText(COL_PERCENT_SUM_PER_THREAD, ""); } const auto color = easyDescriptor(gui_block.tree.node->id()).color(); //const auto bgColor = ::profiler_gui::fromProfilerRgb(::profiler::colors::get_red(color), ::profiler::colors::get_green(color), ::profiler::colors::get_blue(color)); const auto fgColor = ::profiler_gui::textColorForRgb(color);//0x00ffffff - bgColor; item->setBackgroundColor(color); item->setTextColor(fgColor); auto item_index = static_cast<unsigned int>(_items.size()); _items.push_back(item); size_t children_items_number = 0; ::profiler::timestamp_t children_duration = 0; if (!gui_block.tree.children.empty()) { children_items_number = FillTreeClass<T>::setTreeInternal(_safelocker, _items, _beginTime, gui_block.tree.children, item, item, thread_item, _left, _right, _strict, children_duration, _colorizeRows); if (_safelocker.interrupted()) break; } int percentage = 100; auto self_duration = duration - children_duration; if (children_duration > 0 && duration > 0) { percentage = static_cast<int>(0.5 + 100. * static_cast<double>(self_duration) / static_cast<double>(duration)); } item->setTimeSmart(COL_SELF_DURATION, self_duration); item->setData(COL_SELF_DURATION_PERCENT, Qt::UserRole, percentage); item->setText(COL_SELF_DURATION_PERCENT, QString::number(percentage)); if (children_items_number > 0 || !_strict || (startTime >= _left && endTime <= _right)) { //total_items += children_items_number + 1; gui_block.tree_item = item_index; if (_colorizeRows) item->colorize(_colorizeRows); if (gui_block.expanded) item->setExpanded(true); } else { _items.pop_back(); delete item; } _safelocker.setProgress((90 * ++i) / total); } i = 0; total = static_cast<int>(threadsMap.size()); for (auto& it : threadsMap) { auto item = it.second; if (item->childCount() > 0) { //addTopLevelItem(item); //m_roots[it.first] = item; //_items.push_back(item); _topLevelItems.emplace_back(it.first, item); //++total_items; } else { delete item; } _safelocker.setProgress(90 + (10 * ++i) / total); } _safelocker.setDone(); //return total_items; }
DecodeResults * SegmentDecoder :: decode(Instance *inst, Parameter *param) { Items *items = inst->items(); int len = items->size(); int numFeatures = m_Model->getAlphabet("FEATURES")->size(); int numLabels = m_Model->getAlphabet("LABELS")->size(); double **uniScoreCache = new double *[len]; for (int i = 0; i < len; ++ i) { uniScoreCache[i] = new double[numLabels]; Item *item = items->at(i); for (int label = 0; label < numLabels; ++ label) { uniScoreCache[i][label] = 0.0; int sz = item->size(label); for (int j = 0; j < sz; ++ j) { uniScoreCache[i][label] += param->value(item->at(j, label)); } } } double **biScoreCache = new double *[numLabels + 1]; for (int prevLabel = 0; prevLabel <= numLabels; ++ prevLabel) { biScoreCache[prevLabel] = new double[numLabels]; for (int currLabel = 0; currLabel < numLabels; ++ currLabel) { biScoreCache[prevLabel][currLabel] = param->value( numFeatures * numLabels + prevLabel * numLabels + currLabel); } } KHeap<DecodeState> **states = new KHeap<DecodeState> *[len]; for (int i = 0; i < len; ++ i) { states[i] = new KHeap<DecodeState>[numLabels]; for (int j = 0; j < numLabels; ++ j) { states[i][j].setK(m_Agenda); } } for (int i = 0; i < len; ++ i) { // fprintf(stderr, "i=%d\n", i); for (int currLabel = 0; currLabel < numLabels; ++ currLabel) { if (i == 0) { // fprintf(stderr, "!%d->%d\n", numLabels, currLabel); if (m_Legal[numLabels][currLabel] == 0) { continue; } double score = uniScoreCache[0][currLabel] + biScoreCache[numLabels][currLabel]; states[i][currLabel].insert(DecodeState(currLabel, score, NULL)); } else { for (int prevLabel = 0; prevLabel < numLabels; ++ prevLabel) { if (m_Legal[prevLabel][currLabel] == 0) continue; for (int j = 0; j < states[i - 1][prevLabel].size(); ++ j) { DecodeState *prev = states[i - 1][prevLabel].at(j); double score = prev->score + uniScoreCache[i][currLabel] + biScoreCache[prevLabel][currLabel]; // printf("#%d->%d\n", prevLabel, currLabel); states[i][currLabel].insert(DecodeState(currLabel, score, prev)); } } } } } vector<DecodeState> result_cache; for (int label = 0; label < numLabels; ++ label) { for (int i = 0; i < states[len - 1][label].size(); ++ i) { result_cache.push_back( *states[len - 1][label].at(i) ); } } sort( result_cache.begin(), result_cache.end() ); DecodeResults *ret = new CppDecodeResults(); for (int i = 0; ((i < m_Agenda) && (result_cache.size() - i > 0)); ++ i) { Labels* single = new CppLabels(len); int pos = len - 1; DecodeState *now = &result_cache[result_cache.size() - i - 1]; //DecodeState *now = result_cache.at(i); for (; pos >= 0; -- pos, now = now->prev) { single->set(now->label, pos); } ret->append( single ); } for (int i = 0; i < len; ++ i) { delete []uniScoreCache[i]; } delete []uniScoreCache; for (int i = 0; i <= numLabels; ++ i) { delete []biScoreCache[i]; } delete []biScoreCache; for (int i = 0; i < len; ++ i) { delete []states[i]; } delete []states; return ret; }