// accept a time step into the solution history void e_trsolver::acceptstep_sync() { statIterations += iterations; if (--convError < 0) convHelper = 0; // Now advance in time or not... if (running > 1) { adjustDelta_sync (current); // deltaOld = delta; // stepDelta = deltaOld; // nextStates (); // rejected = 0; adjustOrder (); } else { fillStates (); nextStates (); rejected = 0; } saveCurrent = current; current += delta; running++; converged++; // Tell integrators to be running. setMode (MODE_NONE); // Initialize or update history. if (running > 1) { // update the solution history with the new results updateHistory (current); } else { // we have just solved the first transient state initHistory (current); } // store the current time lastsynctime = current; }
// asynchronous step solver int e_trsolver::stepsolve_async(nr_double_t steptime) { // Start to sweep through time. int error = 0; convError = 0; time = steptime; // update the interpolation time of any externally controlled // components which require it. updateExternalInterpTime(time); // make the stored histories for all ircuits that have // requested them at least as long as the next major time // step so we can reject the step later if needed and // restore all the histories to their previous state updateHistoryAges (time - lastasynctime); //delta = (steptime - time) / 10; //if (progress) logprogressbar (i, swp->getSize (), 40); #if DEBUG && 0 messagefcn (LOG_STATUS, "NOTIFY: %s: solving netlist for t = %e\n", getName (), (double) time); #endif do { #if STEPDEBUG if (delta == deltaMin) { messagefcn (LOG_ERROR, "WARNING: %s: minimum delta h = %.3e at t = %.3e\n", getName (), (double) delta, (double) current); } #endif // update the integration coefficients updateCoefficients (delta); // Run predictor to get a start value for the solution vector for // the successive iterative corrector process error += predictor (); // restart Newton iteration if (rejected) { restart (); // restart non-linear devices rejected = 0; } // Run corrector process with appropriate exception handling. // The corrector iterates through the solutions of the integration // process until a certain error tolerance has been reached. try_running () // #defined as: do { { error += corrector (); } catch_exception () // #defined as: } while (0); if (estack.top ()) switch (estack.top()->getCode ()) { case EXCEPTION_NO_CONVERGENCE: pop_exception (); // Reduce step-size (by half) if failed to converge. if (current > 0) current -= delta; delta /= 2; if (delta <= deltaMin) { delta = deltaMin; adjustOrder (1); } if (current > 0) current += delta; // Update statistics. statRejected++; statConvergence++; rejected++; converged = 0; error = 0; // Start using damped Newton-Raphson. convHelper = CONV_SteepestDescent; convError = 2; #if DEBUG messagefcn (LOG_ERROR, "WARNING: delta rejected at t = %.3e, h = %.3e " "(no convergence)\n", (double) saveCurrent, (double) delta); #endif break; default: // Otherwise return. estack.print (); error++; break; } if (error) return -1; if (rejected) continue; // check whether Jacobian matrix is still non-singular if (!A->isFinite ()) { messagefcn (LOG_ERROR, "ERROR: %s: Jacobian singular at t = %.3e, " "aborting %s analysis\n", getName (), (double) current, getDescription ().c_str()); return -1; } // Update statistics and no more damped Newton-Raphson. statIterations += iterations; if (--convError < 0) convHelper = 0; // Now advance in time or not... if (running > 1) { adjustDelta (time); adjustOrder (); } else { fillStates (); nextStates (); rejected = 0; } saveCurrent = current; current += delta; running++; converged++; // Tell integrators to be running. setMode (MODE_NONE); // Initialize or update history. if (running > 1) { updateHistory (saveCurrent); } else { initHistory (saveCurrent); } } while (saveCurrent < time); // Hit a requested time point? return 0; }
/* This function tries to adapt the current time-step according to the global truncation error. */ void e_trsolver::adjustDelta_sync (nr_double_t t) { deltaOld = delta; // makes a new delta based on truncation error // delta = checkDelta (); if (delta > deltaMax) { delta = deltaMax; } if (delta < deltaMin) { delta = deltaMin; } // delta correction in order to hit exact breakpoint int good = 0; // if (!relaxTSR) // relaxed step raster? // { // if (!statConvergence || converged > 64) /* Is this a good guess? */ // { // // check next breakpoint // if (stepDelta > 0.0) // { // // restore last valid delta // delta = stepDelta; // stepDelta = -1.0; // } // else // { // if (delta > (t - current) && t > current) // { // // save last valid delta and set exact step // stepDelta = deltaOld; // delta = t - current; // good = 1; // } // else // { // stepDelta = -1.0; // } // } // if (delta > deltaMax) delta = deltaMax; // if (delta < deltaMin) delta = deltaMin; // } // } stepDelta = -1; good = 1; // usual delta correction if (delta > 0.9 * deltaOld || good) // accept current delta { nextStates (); rejected = 0; #if STEPDEBUG logprint (LOG_STATUS, "DEBUG: delta accepted at t = %.3e, h = %.3e\n", (double) current, (double) delta); #endif } else if (deltaOld > delta) // reject current delta { rejected++; statRejected++; #if STEPDEBUG logprint (LOG_STATUS, "DEBUG: delta rejected at t = %.3e, h = %.3e\n", (double) current, (double) delta); #endif if (current > 0) current -= deltaOld; } else { nextStates (); rejected = 0; } }
bool Entity::updateState(cv::Mat image, int timeMS) { cv::Mat result; cv::Point minLoc; cv::Point maxLoc; double minVal; double maxVal; int method = cv::TM_SQDIFF; int x_margin, y_margin; int x, y, width, height; if (type == EntityType::MARIO_SMALL_L || type == EntityType::MARIO_SMALL_R || type == EntityType::MARIO_BIG_L || type == EntityType::MARIO_BIG_R || type == EntityType::MARIO_FIRE_L || type == EntityType::MARIO_FIRE_R) { x_margin = 10; y_margin = 10; } else if (type == EntityType::GOOMBA || type == EntityType::BEAM) { x_margin = 6; y_margin = 10; } else { x_margin = 5; y_margin = 5; } if (!isInFrame && ( type == EntityType::MARIO_SMALL_L || type == EntityType::MARIO_SMALL_R || type == EntityType::MARIO_BIG_L || type == EntityType::MARIO_BIG_R || type == EntityType::MARIO_FIRE_L || type == EntityType::MARIO_FIRE_R)) { x = 0; y = 0; width = image.cols; height = image.rows; } else { x = std::max(0, bbox.x + loc.x - x_margin); width = std::min(bbox.width + x_margin * 2, image.cols - x); y = std::max(0, bbox.y + loc.y - y_margin); height = std::min(bbox.height + y_margin * 2, image.rows - y); } cv::Mat roi = image(cv::Rect(x, y, width, height)); // cv::Mat roi = image.clone(); if (type == EntityType::MARIO_SMALL_L || type == EntityType::MARIO_SMALL_R || type == EntityType::MARIO_BIG_L || type == EntityType::MARIO_BIG_R || type == EntityType::MARIO_FIRE_L || type == EntityType::MARIO_FIRE_R) { } std::vector<EntityType> possStates = nextStates(); for (EntityType tmpType : possStates) { // Create the result matrix int result_cols = roi.cols - spriteTable[tmpType].cols + 1; int result_rows = roi.rows - spriteTable[tmpType].rows + 1; result.create(result_rows, result_cols, CV_32FC1); cv::Mat resultImg = result.clone(); // Do the Matching and Normalize cv::matchTemplate(roi, spriteTable[tmpType], result, method); // Try and find the first enemy template cv::minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat()); if (minVal < getDetThresh(tmpType)) { // We found it if (!isInFrame && ( type == EntityType::MARIO_SMALL_L || type == EntityType::MARIO_SMALL_R || type == EntityType::MARIO_BIG_L || type == EntityType::MARIO_BIG_R || type == EntityType::MARIO_FIRE_L || type == EntityType::MARIO_FIRE_R)) { loc = minLoc; } else { loc = cv::Point(minLoc.x + loc.x + bbox.x - x_margin, minLoc.y + loc.y + bbox.y - y_margin); } type = tmpType; setBoundingBox(); isInFrame = true; msLastSeen = timeMS; return true; } } isInFrame = false; return false; }