const Tracks& NearestNeighborTracker::processCycle(double currentTime, const Observations& newObservations, const Observations& additionalLowConfidenceObservations) { beginCycle(currentTime); predictTrackStates(); m_occlusionManager->manageOcclusionsBeforeDataAssociation(m_tracks, ros::Time(currentTime), m_frameID); predictMeasurements(); Pairings pairings = performDataAssociation(m_tracks, newObservations); // Extension to default NNT: If there are additional low-confidence observations (e.g. from a high-recall blob detector), // try to match these against the tracks which are so far unmatched (but only if we are sufficiently sure that it is a valid track). if(!additionalLowConfidenceObservations.empty()) { int minNumMatchesToAllowLowConfidenceMatch = Params::get<int>("min_num_matches_to_allow_low_confidence_match", 10); Tracks unmatchedTracks; foreach(Track::Ptr track, m_tracks) { if(track->trackStatus == Track::OCCLUDED && track->numberOfTotalMatches >= minNumMatchesToAllowLowConfidenceMatch) { unmatchedTracks.push_back(track); } } if(!unmatchedTracks.empty()) { Pairings additionalPairings = performDataAssociation(unmatchedTracks, additionalLowConfidenceObservations); pairings.insert(pairings.end(), additionalPairings.begin(), additionalPairings.end()); } }
void GetTracksTabSeparated(string const& path, Tracks& tracks, vector<string>& names) { tracks.clear(); // Read the file to get our tracks ifstream ifs(path); string line; int idx = 0; while (getline(ifs, line)) { stringstream ss(line); string name; getline(ss, name, '\t'); string key_str; getline(ss, key_str, '\t'); Key key = Key::KeyFromString(key_str); double bpm; ss >> bpm; // Allow commenting out tracks if (!name.substr(0, 2).compare("//")) { continue; } tracks.push_back(Track(idx++, bpm, key)); names.push_back(name); } ifs.close(); }
Tracks * loadTracks(Int_t Runs, Int_t dataType, Float_t energy) { TString sDataType = (dataType == 0) ? "_MC_" : "_data_"; TString sAbsThick = Form("_%.0fmm", kAbsorbatorThickness); TString sEnergy = Form("_%.2fMeV", energy); TString fileName = "Data/Tracks/tracks"; TString sMaterial = getMaterialChar(); fileName.Append(sDataType); fileName.Append(sMaterial); fileName.Append(sAbsThick); fileName.Append(sEnergy); fileName.Append(".root"); TFile *f = new TFile(fileName); if (!f) return 0; TTree *T = (TTree*) f->Get("T"); Tracks * tracks = new Tracks(); T->GetBranch("tracks")->SetAutoDelete(kFALSE); T->SetBranchAddress("tracks",&tracks); T->GetEntry(0); cout << "There are " << tracks->GetEntriesFast() << " tracks in " << fileName << ".\n"; return tracks; }
int CreateDVD_Thread:: option_presets() { if( !mwindow->edl ) return 1; Tracks *tracks = mwindow->edl->tracks; int max_w = 0, max_h = 0; int has_deinterlace = 0, has_scale = 0; for( Track *trk=tracks->first; trk; trk=trk->next ) { if( !trk->record ) continue; Edits *edits = trk->edits; switch( trk->data_type ) { case TRACK_VIDEO: for( Edit *edit=edits->first; edit; edit=edit->next ) { Indexable *indexable = edit->get_source(); int w = indexable->get_w(); if( w > max_w ) max_w = w; if( w != DVD_WIDTH ) use_scale = 1; int h = indexable->get_h(); if( h > max_h ) max_h = h; if( h != DVD_HEIGHT ) use_scale = 1; } for( int i=0; i<trk->plugin_set.size(); ++i ) { for(Plugin *plugin = (Plugin*)trk->plugin_set[i]->first; plugin; plugin = (Plugin*)plugin->next) { if( !strcmp(plugin->title, "Deinterlace") ) has_deinterlace = 1; if( !strcmp(plugin->title, "Scale") ) has_scale = 1; } } break; } } if( has_scale ) use_scale = 0; for( Track *trk=tracks->first; trk && !use_resize_tracks; trk=trk->next ) { if( !trk->record ) continue; switch( trk->data_type ) { case TRACK_VIDEO: if( trk->track_w != max_w ) use_resize_tracks = 1; if( trk->track_h != max_h ) use_resize_tracks = 1; break; } } if( !has_deinterlace && max_h > 2*DVD_HEIGHT ) use_deinterlace = 1; Labels *labels = mwindow->edl->labels; use_label_chapters = labels && labels->first ? 1 : 0; float w, h; MWindow::create_aspect_ratio(w, h, max_w, max_h); if( w == DVD_WIDE_ASPECT_WIDTH && h == DVD_WIDE_ASPECT_HEIGHT ) use_wide_aspect = 1; if( tracks->recordable_audio_tracks() == DVD_WIDE_CHANNELS ) use_wide_audio = 1; return 0; }
bool MidiPlayerThread::start( const QString &path, int volume, double seek /* = -1 */ ) { qDebug() << "MidiPlayerThread::start"; unsigned short int mixer_options = 0; m_path = path; if ( open_alsa_output() == ( -1 ) ) { qDebug() << "MidiPlayerThread::start: error of open_alsa_output()..."; return false; } if ( WildMidi_Init( qPrintable( m_configFile ), m_sample_rate, mixer_options ) < 0 ) { qWarning( "MidiPlayerThread::start: unable to initialize WildMidi library" ); close_output(); return false; } m_midiPtr = WildMidi_Open ( qPrintable( m_path ) ); if ( !m_midiPtr ) { qWarning("MidiPlayerThread::start: unable to open file"); WildMidi_Shutdown(); close_output(); return false; } Tracks audios; audios.addID( 0 ); _WM_Info *wm_info = WildMidi_GetInfo( m_midiPtr ); m_totalTime = ( qint64 )wm_info->approx_total_samples / m_sample_rate; qDebug() << "total time is " << m_totalTime << " sec"; m_md->reset(); m_md->duration = m_totalTime; m_md->audio_rate = m_sample_rate; m_md->novideo = true; m_md->audios = audios; // m_md->type = TYPE_FILE; setVolume( volume ); if ( seek != ( -1 ) ) { goToSec( seek ); } QThread::start(); qDebug( "MidiPlayerThread: thread started" ); emit audioInfoChanged( audios ); return true; }
Tracks * loadOrCreateTracks(Bool_t recreate, Int_t Runs, Int_t dataType, Float_t energy, Float_t *x, Float_t *y) { Tracks * tracks = nullptr; if (recreate) { printf("kUseAlpide = %d\n", kUseAlpide); if (!kUseAlpide) { tracks = getTracks(Runs, dataType, kCalorimeter, energy, x, y); } else { tracks = getTracksFromClusters(Runs, dataType, kCalorimeter, energy); } if (tracks->GetEntries()) { cout << "Saving " << tracks->GetEntries() << " tracks.\n"; saveTracks(tracks, dataType, energy); } } else { tracks = loadTracks(Runs, dataType, energy); if (!tracks) { cout << "!tracks, creating new file\n"; if (!kUseAlpide) { tracks = getTracks(Runs, dataType, kCalorimeter, energy, x, y); } else { tracks = getTracksFromClusters(Runs, dataType, kCalorimeter, energy); } saveTracks(tracks, dataType, energy); } } return tracks; }
/** Returns the number of tracks. */ size_t getNumberOfTracks() const { return m_tracks.size(); }
int main(int argc, char* argv[]) { RunTests(); // Our tracks Tracks tracks; vector<string> names; //GetTracks("tracks.txt", tracks); GetTracksTabSeparated("tracks_tsv.txt", tracks, names); //// Write separate values out //ofstream names("names.txt"); //ofstream bpms("bpms.txt"); //ofstream keys("keys.txt"); //for (auto t : tracks) { // names << t.name << endl; // bpms << t.bpm << endl; // keys << t.key.short_name << endl; //} //names.close(); //bpms.close(); //keys.close(); // Collect stats on how many tracks are in which keys KeyCount key_counts; for (auto t : tracks) { //key_counts[t.key].push_back(t); key_counts[t.key]++; } // Write the key counts for (auto k : key_counts) { cout << Key::GetShortName(k.first.num, k.first.type) << ": " << k.second << endl; } // Exhaustive solution // Start at each track and try to get as many tracks into a mix as possible // We will exhaustively try to join into each possible next track that is compatible Tracks available = tracks; Tracks best; double best_cost = DBL_MAX; for (size_t i = 0; i < available.size(); ++i) { Tracks chosen; Tracks this_best; double cost = 0; double this_best_cost = DBL_MAX; int its = 0; Tracks now_available = available; Track t = now_available[i]; now_available.erase(now_available.begin() + i); Tracks now_chosen = chosen; now_chosen.push_back(t); cout << "Starting with " << names[t.idx] << endl; ChooseTrack(names, now_available, now_chosen, t.idx, t.key, t.bpm, cost, this_best_cost, kMixSongLen, this_best, its); if (this_best.size() > best.size()) { best = this_best; cout << "New OVERALL best of " << best.size() << " found!" << endl; } else if (this_best.size() == best.size() && this_best_cost < best_cost) { best_cost = this_best_cost; best = this_best; cout << "New OVERALL best cost of " << best_cost << " found!" << endl; } } // Show our results for (auto t : best) { cout << setw(3) << Key::GetShortName(t.key.num, t.key.type) << " @ " << setw(3) << static_cast<int>(t.bpm) << "bpm" << ", " << names[t.idx] << endl; } cout << "Cost is " << best_cost << endl; return EXIT_SUCCESS; //// Sort by BPM //sort(tracks.begin(), tracks.end(), [](Track const& a, Track const& b) //{ // return a.bpm < b.bpm; //}); //// Interactive selection //vector<Track> order; //int idx = 0; //for (;;) { // // Mark our work // Track selected = tracks[idx]; // tracks.erase(tracks.begin() + idx); // order.push_back(selected); // cout << "Your current track: " << selected.name << endl; // // Get options... // vector<TrackOption> options; // for (size_t i = 0; i < tracks.size(); ++i) { // // Must be compatible // if (!AreCompatibleKeys(selected.key, tracks[i].key)) { // continue; // } // // Get the BPM ratio // double bpm_ratio = max(selected.bpm, tracks[i].bpm) / min(selected.bpm, tracks[i].bpm); // //double bpm_ratio_st = log(bpm_ratio) / log(Utils::GetSemitoneRatio()); // // We have an option // TrackOption option(tracks[i], bpm_ratio, i); // options.push_back(option); // } // // Sort by BPM ratio // sort(options.begin(), options.end(), [](TrackOption const& a, TrackOption const& b) // { // return a.bpm_ratio < b.bpm_ratio; // } // ); // // Print options // cout << "Options: " << endl; // for (size_t i = 0; i < options.size(); ++i) { // cout << i << "\t" << fixed << setw(4) << options[i].bpm_ratio << "\t" << options[i].track.name << " (" << options[i].track.key.short_name << ")" << endl; // } // cout << "You have selected " << order.size() << " tracks" << endl; // string choice; // getline(cin, choice); // if (!choice.compare("q")) { // break; // } // stringstream ss(choice); // ss >> idx; // idx = options[idx].idx; //} //// Write our order //ofstream order_f("order.txt"); //for (auto t : order) { // order_f << t.bpm << "\t" << t.name << " (" << t.key.short_name << ")" << endl; //} //order_f.close(); //// Start by just choosing a base track (try each one) //vector<Tracks> options; //// Our starting track //for (auto t : tracks) { // cout << "Starting with " << t.name << endl; // Tracks order; // if (ChooseTrack(t, tracks, order)) { // options.push_back(order); // cout << "Found " << options.size() << " solutions!" << endl; // } //} //// Select a key ordering //vector<Keys> options; //int max_depth = 0; //for (auto k : key_counts) { // cout << "Starting with " << k.first.short_name << endl; // Keys order; // if (ChooseKey(KeyFromString("Dbm") /*k.first*/, key_counts, order, 1, max_depth)) { // options.push_back(order); // cout << "Found " << options.size() << " solutions!" << endl; // } //} // Find a mix that works! MixAnt ma; Mix m = ma.FindMix(tracks); // Print the mix //cout << m << endl; cout << "Mix uses " << m.steps.size() << " of " << tracks.size() << " input tracks" << endl << endl; // Save the mix to a file ofstream ofs("mix.txt"); ofs << m; ofs.close(); // write our unused tracks Tracks unused(tracks); for (auto s : m.steps) { for (auto it = unused.begin(); it != unused.end(); ++it) { if (*it == s.track) { unused.erase(it); break; } } } ofstream unused_f("unused.txt"); for (auto u : unused) { //unused_f << u.name << endl; //unused_f << u.key.short_name << endl; unused_f << u.bpm << endl; } unused_f.close(); //cin.get(); }
void ChooseTrack( vector<string> names, Tracks& available, Tracks& chosen, int prev_idx, Key prev_key, double prev_bpm, double cost, double& best_cost, int max_len, Tracks& best, int& its ) { // We're too long! if (chosen.size() >= static_cast<size_t>(max_len)) { return; } // We have a new best length (more important than cost) if (chosen.size() > best.size()) { best_cost = cost; best = chosen; cout << "New best of length " << best.size() << " found." << endl; its = 0; } // Mix length is the same, but less cost else if (chosen.size() == best.size() && cost < best_cost && !chosen.empty()) { best_cost = cost; cout << "New best cost of " << best_cost << " found." << endl; best = chosen; its = 0; } // No improvement! else { ++its; } // We've spent too long, so bail! if (its >= 1000000) { cout << "Too many iterations without improvement!" << endl; return; } // Nothing to look at if (available.empty()) { cout << "No more tracks to choose." << endl; return; } Track prev(prev_idx, prev_bpm, prev_key); // Go through all available and find those compatible Tracks candidates; Keys candidates_adj; vector<double> candidate_costs; for (auto t : available) { Key candidate_adj; double this_cost; if (AreCompatibleTracks( prev, t, kBPMThresh, kKeyShiftThresh, candidate_adj, this_cost )) { candidates.push_back(t); candidates_adj.push_back(candidate_adj); candidate_costs.push_back(this_cost); } } for (size_t i = 0; i < candidates.size(); ++i) { Tracks now_available = available; Track t = candidates[i]; // Erase the candidate from the now available list for (size_t j = 0; j < now_available.size(); ++j) { if (now_available[j] == t) { now_available.erase(now_available.begin() + j); break; } } // Set to our new key t.key = candidates_adj[i]; Tracks now_chosen = chosen; now_chosen.push_back(t); // NOTE: We send in an ADJUSTED key for this track! ChooseTrack(names, now_available, now_chosen, t.idx, t.key, t.bpm, cost + candidate_costs[i], best_cost, max_len, best, its); } }
void makeTracks(Int_t Runs, Int_t dataType, Bool_t recreate, Float_t energy) { Tracks * tracks = loadOrCreateTracks(recreate, Runs, dataType, energy); tracks->extrapolateToLayer0(); }
Tracks * getTracks(Int_t Runs, Int_t dataType, Int_t frameType, Float_t energy, Float_t *x, Float_t *y) { run_energy = energy; DataInterface * di = new DataInterface(); Misalign * m = new Misalign(); Int_t nClusters = kEventsPerRun * 5 * nLayers; Int_t nHits = kEventsPerRun * 50; Int_t nTracks = kEventsPerRun * 2; Bool_t breakSignal = false; CalorimeterFrame *cf = new CalorimeterFrame(); Clusters * clusters = new Clusters(nClusters); Clusters * trackerClusters = new Clusters(nClusters); Hits * hits = new Hits(nHits); Hits * eventIDs = new Hits(kEventsPerRun * sizeOfEventID); Int_t eventID = -1; Hits * trackerHits = new Hits(nHits); Tracks * calorimeterTracks = nullptr; Tracks * trackerTracks = new Tracks(nTracks); Tracks * allTracks = new Tracks(nTracks * Runs); TRandom3 * gRandom = new TRandom3(0); TStopwatch t1, t2, t3, t4, t5, t6; ofstream file("OutputFiles/efficiency.csv", ofstream::out | ofstream::app); Int_t totalNumberOfFrames = 0; Int_t tracksTotalNumberAfterRecon = 0; Int_t tracksRemovedDueToBadChannels = 0; Int_t tracksGivenToReconstruction = 0; Int_t tracksRemovedDueToLeavingDetector = 0; Int_t tracksRemovedDueToNuclearInteractions = 0; Int_t clustersInFirstLayer = 0; Int_t tracksRemovedDueToCollisions = 0; // file: np; number of reconstructed tracks; tracks after removeTracksLeavingDetector; tracks after removeTrackCollisions for (Int_t i=0; i<Runs; i++) { cout << "Finding track " << (i+1)*kEventsPerRun << " of " << Runs*kEventsPerRun << "... "; if (dataType == kMC) { t1.Start(); eventID = di->getMCFrame(i, cf, x, y); di->getEventIDs(i, eventIDs); t1.Stop(); t2.Start(); showDebug("Start diffuseFrame\n"); cf->diffuseFrame(gRandom); showDebug("End diffuseFrame, start findHits\n"); t2.Stop(); t3.Start(); hits = cf->findHits(eventID); showDebug("Number of hits in frame: " << hits->GetEntriesFast() << endl); t3.Stop(); t4.Start(); clusters = hits->findClustersFromHits(); // badly optimized cout << "Found " << clusters->GetEntriesInLayer(0) << " clusters in the first layer.\n"; cout << "Found " << clusters->GetEntriesInLayer(1) << " clusters in the second layer.\n"; clusters->removeSmallClusters(2); cout << "Found " << clusters->GetEntriesInLayer(0) << " clusters in the first layer after removeSmallClusters.\n"; t4.Stop(); clusters->matchWithEventIDs(eventIDs); eventIDs->Clear(); } else if (dataType == kData) { t1.Start(); di->getDataFrame(i, cf, energy); t1.Stop(); t3.Start(); hits = cf->findHits(); t3.Stop(); t4.Start(); clusters = hits->findClustersFromHits(); t4.Stop(); clusters->removeSmallClusters(2); clusters->removeAllClustersAfterLayer(8); // bad data in layer 10 and 11 cout << "Found " << clusters->GetEntriesInLayer(0) << " clusters in the first layer.\n"; cout << "Found " << clusters->GetEntriesInLayer(1) << " clusters in the second layer.\n"; m->correctClusters(clusters); } t5.Start(); calorimeterTracks = clusters->findCalorimeterTracks(); t5.Stop(); tracksTotalNumberAfterRecon += calorimeterTracks->GetEntries(); if (calorimeterTracks->GetEntriesFast() == 0) breakSignal = kTRUE; // to stop running // Track improvements Int_t nTracksBefore = 0, nTracksAfter = 0; Int_t nIsInelastic = 0, nIsNotInelastic = 0; calorimeterTracks->extrapolateToLayer0(); calorimeterTracks->splitSharedClusters(); nTracksBefore = calorimeterTracks->GetEntries(); calorimeterTracks->removeTracksLeavingDetector(); nTracksAfter = calorimeterTracks->GetEntries(); tracksRemovedDueToLeavingDetector += nTracksBefore - nTracksAfter; cout << "Of " << nTracksBefore << " tracks, " << nTracksBefore - nTracksAfter << " (" << 100* ( nTracksBefore - nTracksAfter) / ( (float) nTracksBefore ) << "%) were lost when leaving the detector.\n"; nTracksBefore = calorimeterTracks->GetEntries(); calorimeterTracks->removeTrackCollisions(); nTracksAfter = calorimeterTracks->GetEntries(); tracksRemovedDueToCollisions += nTracksBefore - nTracksAfter; if (kDataType == kData) { nTracksBefore = calorimeterTracks->GetEntries(); calorimeterTracks->removeTracksEndingInBadChannels(); nTracksAfter = calorimeterTracks->GetEntries(); cout << "Of " << nTracksBefore << " tracks, " << nTracksBefore - nTracksAfter << " (" << 100* ( nTracksBefore - nTracksAfter) / ( (float) nTracksBefore ) << "%) were removed due to ending just before a bad channel.\n"; tracksRemovedDueToBadChannels += nTracksBefore - nTracksAfter; } for (Int_t k=0; k<calorimeterTracks->GetEntriesFast(); k++) { if (calorimeterTracks->At(k)) { if (calorimeterTracks->At(k)->doesTrackEndAbruptly()) { nIsInelastic++; } else nIsNotInelastic++; } } tracksRemovedDueToNuclearInteractions += nIsInelastic; cout << "Of these, " << nIsInelastic << " end abruptly and " << nIsNotInelastic << " does not.\n"; file << energy << " " << kEventsPerRun << " " << nTracksBefore << " " << nTracksAfter << " " << calorimeterTracks->GetEntries() << " " << nIsInelastic << " " << nIsNotInelastic << endl; // calorimeterTracks->retrogradeTrackImprovement(clusters); calorimeterTracks->Compress(); calorimeterTracks->CompressClusters(); for (Int_t j=0; j<calorimeterTracks->GetEntriesFast(); j++) { if (!calorimeterTracks->At(j)) continue; allTracks->appendTrack(calorimeterTracks->At(j)); tracksGivenToReconstruction++; } allTracks->appendClustersWithoutTrack(clusters->getClustersWithoutTrack()); cout << Form("Timing: getMCframe (%.2f sec), diffuseFrame (%.2f sec), findHits (%.2f sec), findClustersFromHits (%.2f sec), findTracks (%.2f sec)\n", t1.RealTime(), t2.RealTime(), t3.RealTime(), t4.RealTime(), t5.RealTime()); cf->Reset(); hits->clearHits(); trackerHits->clearHits(); clusters->clearClusters(); trackerClusters->clearClusters(); calorimeterTracks->Clear(); trackerTracks->Clear(); if (breakSignal) break; } printf("\033[1mTrack statics for article. Clusters found in first layer (= N protons) = %d. Total number of tracks found = %d. Total number of tracks given to reconstruction = %d. Tracks removed due to bad channels = %d. Tracks removed due to nuclear interactions = %d. Tracks removed due to leaving the detector laterally = %d. Tracks removed due to collisions = %d. Sum = %d.\033[0m\n", clustersInFirstLayer, tracksTotalNumberAfterRecon, tracksGivenToReconstruction, tracksRemovedDueToBadChannels, tracksRemovedDueToNuclearInteractions, tracksRemovedDueToLeavingDetector, tracksRemovedDueToCollisions, tracksGivenToReconstruction + tracksRemovedDueToBadChannels + tracksRemovedDueToLeavingDetector + tracksRemovedDueToCollisions); file.close(); delete cf; delete clusters; delete trackerClusters; delete hits; delete trackerHits; delete calorimeterTracks; delete trackerTracks; delete di; return allTracks; }
Tracks * getTracksFromClusters(Int_t Runs, Int_t dataType, Int_t frameType, Float_t energy) { run_energy = energy; DataInterface * di = new DataInterface(); Int_t nClusters = kEventsPerRun * 5 * nLayers; Int_t nTracks = kEventsPerRun * 2; Bool_t breakSignal = false; Clusters * clusters = new Clusters(nClusters); Tracks * tracks = new Tracks(nTracks); Tracks * allTracks = new Tracks(nTracks * Runs); for (Int_t i=0; i<Runs; i++) { showDebug("Start getMCClusters\n"); di->getMCClusters(i, clusters); showDebug("Finding calorimeter tracks\n"); tracks = clusters->findCalorimeterTracksWithMCTruth(); if (tracks->GetEntriesFast() == 0) breakSignal = kTRUE; // to stop running // Track improvements Int_t nTracksBefore = 0, nTracksAfter = 0; Int_t nIsInelastic = 0, nIsNotInelastic = 0; tracks->extrapolateToLayer0(); nTracksBefore = tracks->GetEntries(); tracks->removeTracksLeavingDetector(); nTracksAfter = tracks->GetEntries(); cout << "Of " << nTracksBefore << " tracks, " << nTracksBefore - nTracksAfter << " (" << 100* ( nTracksBefore - nTracksAfter) / ( (float) nTracksBefore ) << "%) were lost when leaving the detector.\n"; tracks->removeTrackCollisions(); // tracks->retrogradeTrackImprovement(clusters); tracks->Compress(); tracks->CompressClusters(); for (Int_t j=0; j<tracks->GetEntriesFast(); j++) { if (!tracks->At(j)) continue; allTracks->appendTrack(tracks->At(j)); } allTracks->appendClustersWithoutTrack(clusters->getClustersWithoutTrack()); clusters->clearClusters(); tracks->Clear(); if (breakSignal) break; } delete clusters; delete tracks; delete di; return allTracks; }