void WordcodeEmitter::peep(uint32_t opcode, uintptr_t* loc) { const peep_state_t *s; uint32_t limit, next_state; AvmAssert(opcode != OP_lookupswitch); if (state == 0) goto initial_state; if (opcode == 0) { s = &states[state]; goto accept; } // Search for a transition from the current state to a next // state on input 'opcode'. O[nextI] = opcode; I[nextI] = loc; nextI++; s = &states[state]; limit = s->numTransitions; // The transition lists can get quite long for popular instructions like GETLOCAL; // binary search if it that might be profitable. if (limit > 4) { int32_t lo = s->transitionPtr; int32_t hi = lo + limit - 1; while (lo <= hi) { uint32_t mid = (unsigned)(lo + hi) / 2; uint32_t probe = transitions[mid].opcode; if (probe == opcode) { next_state = transitions[mid].next_state; goto found; } if (opcode < probe) hi = mid-1; else lo = mid+1; } next_state = 0; } else { const peep_transition_t* t = &transitions[s->transitionPtr]; uint32_t i = 0; while (i < limit && t->opcode != opcode) i++, t++; next_state = (i == limit) ? 0 : t->next_state; } found: if (next_state != 0) { // Advance // // There is a next state, so push the current state on the backtrack // stack if it is final, and move to the next state. If that state has // successor states then return, as the search continues. Otherwise, the // next state must be final and we try to accept. // // (The shortcut of checking the successors is necessary for correctness, // as otherwise the peephole window could contain a branch in the non-final // position.) if (s->guardAndAction != 0) backtrack_stack[backtrack_idx++] = state; advance: state = next_state; s = &states[state]; if (s->numTransitions > 0) return; next_state = 0; AvmAssert(s->guardAndAction != 0); } // Accept // // The next state is 0. Commit to 'state' if it is final; otherwise to // successive backtrack states. Committing means checking the guard // (which may fail, forcing further backtracking) and if the guard passes // then performing the transformation. The commit function is generated, // see above; the replace logic is in the function replace() above. accept: if (s->guardAndAction && commit(s->guardAndAction)) return; for ( int bi=backtrack_idx-1 ; bi >= 0 ; bi-- ) { const peep_state_t *b = &states[backtrack_stack[bi]]; AvmAssert(b->guardAndAction != 0); if (commit(b->guardAndAction)) return; } // If we could not accept or backtrack because of failing guards then // try the failure state, if defined. We discard anything not relevant // to the failure state by shifting the window, so relevant instructions // always begin in offset 0 of the window. if (s->fail != 0) { shiftBuffers(s->failShift); next_state = s->fail; goto advance; } // If we failed to find an accepting state then fall through to initial_state // to reset the machine. Resetting discards the first instruction only, // other cases - where larger shifts are possible - are handled above, because // in that case s->fail will be nonzero. // // After shifting, rerun the optimizer on the input buffer, since there may // be optimization opportunities there. shiftBuffers(1); if (nextI > 0) { replace(0, 0); peepFlush(); } return; initial_state: AvmAssert(opcode < WOP_LAST+1); state = toplevel[opcode]; // may remain 0 nextI = 0; backtrack_idx = 0; if (state != 0) { O[nextI] = opcode; I[nextI] = loc; nextI++; } }
void PTracker::run() { IdGenerator idGenerator(0); frameCount = 0; while(true) { SubFrame subResult = receive(subtractorBuffer); ClasifierFrame detectionResult = receive(classifierBuffer); bool buffersFull = shiftBuffers(subResult, detectionResult); if(!buffersFull) continue; frameCount++; #if PROCESS #pragma region setting data for time t auto detections = detectionBuffer[1]; auto currentFrame = frameBuffer[1]; auto currentGrayFrame = grayFrameBuffer[1]; auto prevFrame = frameBuffer[0]; auto currentForeground = foregroundBuffer[1]; #pragma endregion #pragma region init tracks from first detections if(tracks.size() == 0 && detections.size() > 0) { tracks.clear(); tracks.reserve(detections.size()); for_each(begin(detections), end(detections), [&](detection& d){ createTrack(d, idGenerator, currentGrayFrame); }); continue; } #pragma endregion #pragma region predict track positions for time t auto lkoutput = currentFrame.clone(); deleteExitedTracks(); beginTracking(); for(auto it = begin(tracks); it != end(tracks); it++) registerForTracking(*it); performTracking(); for(auto it = begin(tracks); it != end(tracks); it++) { Rect kanadePrediction, kalmanPrediction; bool lucasSuccess = getMedianFlowPrediction(*it, kanadePrediction); bool kalmanSuccess = getKalmanPrediction(*it, kalmanPrediction); float minDist = 999999; auto finalPrediction = mergePredictions(lucasSuccess, kalmanSuccess, *it, kanadePrediction, kalmanPrediction, grayFrameBuffer, minDist); it->assign(finalPrediction); it->predictionDist = minDist; } #pragma endregion std::map<int, trackMatch> trMatches; std::map<int, detectionMatch> detMatches; matcher->begin(); secMatcher->begin(); for_each(begin(tracks), end(tracks), [&](track& tr){ auto dit = detections.begin(); auto dend = detections.end(); for(;dit != dend; ++dit) { float score = matcher->match(tr, *dit, currentGrayFrame); if(score < 0) continue; float dist = secMatcher->match(tr, *dit, currentGrayFrame); if(dist > secMatcher->goodMaxDist) { continue; } trackMatch trMatch = {dit->id, score}; detectionMatch dMatch = {tr.id, score}; if(detMatches.find(dit->id) == detMatches.end()) { trMatches[tr.id] = trMatch; detMatches[dit->id] = dMatch; }else if(detMatches[dit->id].score < score) { auto exmatch = detMatches[dit->id]; trMatches.erase(exmatch.trackId); trMatches[tr.id] = trMatch; detMatches[dit->id] = dMatch; } } }); #pragma region update track models and kalman for_each(begin(tracks), end(tracks), [&](track& tr){ if(trMatches.find(tr.id) != trMatches.end())//matched detection with track { auto m = trMatches[tr.id]; matcher->inferModel(tr, detections[m.detectionId], currentGrayFrame); secMatcher->inferModel(tr, detections[m.detectionId], currentGrayFrame); validators[tr.id].tick(true); correctKalman(tr); }else {//detection not found for track float max = secMatcher->maxSimilarityDist; float dist = tr.predictionDist; if(dist < max) validators[tr.id].tick(true); else validators[tr.id].tick(false); forwardKalman(tr); } }); #pragma endregion #pragma region init new tracks from unmatched detections for_each(begin(detections), end(detections), [&](detection& mockdet){ auto it = detMatches.find(mockdet.id); if(it == detMatches.end()){ auto inited = createTrack(mockdet, idGenerator, currentGrayFrame); trackMatch m = {mockdet.id, 1}; trMatches[inited.id] = m; } }); #pragma endregion #pragma region drawing_results if(debugPrint) { printf("frame %d========\n", frameCount); for(auto it = begin(tracks); it != end(tracks); it++) { if(trMatches.find(it->id) != trMatches.end()) printf("track %d : detection %d\n", it->id, trMatches[it->id].detectionId); } cv::waitKey(); } auto fclone = currentFrame.clone(); DrawExtensions::drawDetections(detections, fclone); DrawExtensions::drawTracks(tracks, fclone, Scalar(255,0,0)); for_each(begin(tracks), end(tracks), [&](track& tr){ Draw::rect(tr.model.kalmanRect, fclone, Scalar(0,0,255)); }); //imshow("xxx", currentForeground); //cv::waitKey(50); std::stringstream str; str << carCount; Draw::text(str.str(), Point(10,20), fclone, Scalar(255,255,0)); imshow("kalman", fclone); fclone.release(); lkoutput.release(); #pragma endregion #endif char key; key = cv::waitKey(1.); if(key == 's') debugPrint = true; else if(key == 'f') debugPrint = false; send(syncBuffer,1); } }