// remount / void Dialog::on_pushButton_remount_root_released() { if(!check_if_can_run(false)) return; int ret = backup::do_cmd_return_str("adb shell busybox mount -o remount,rw / 2>&1", ui->textEdit_result); if(ret != 0) update_result(msg_alert, "Remount root Error!\n"); else update_result(msg_succeed, "Remount root ok!\n"); }
// update hardware void Dialog::on_pushButton_update_hardware_released() { if(!check_if_can_run(false)) return; int ret = backup::do_cmd_return_str("adb push /home/kangear/ybk-hw/ybkMisc/out/target/product/rk30sdk/system/lib/hw/print.default.so /system/lib/hw/ 2>&1", ui->textEdit_result); if(ret != 0) update_result(msg_alert, "Update hardware Error!\n"); else update_result(msg_succeed, "Update hardware ok!\n"); }
// update services.jar void Dialog::on_pushButton_update_services_released() { if(!check_if_can_run(false)) return; int ret = backup::do_cmd_return_str(get_cmd_update_services_jar(), ui->textEdit_result); if(ret != 0) update_result(msg_alert, "Update services java Error!\n"); else update_result(msg_succeed, "Update services java ok!\n"); }
// reboot device void Dialog::on_pushButton_reboot_released() { if(!check_if_can_run(false)) return; int ret = backup::do_cmd_return_str("adb reboot 2>&1", ui->textEdit_result); if(ret != 0) update_result(msg_alert, "Reboot failed!"); else update_result(msg_succeed, "Reboot succeed!"); update_ui(); }
int my_getnbr(const char *str) { char sign; unsigned int i; int length; int result; unsigned char overflow; sign = '+'; i = 0; length = my_strlen(str); result = 0; overflow = 0; while (i < length && check_valid(str[i]) && !overflow) { if (str[i] == '+' || str[i] == '-') { add_sign(&sign, str[i]); } else { overflow = update_result(&result, str[i], sign); } i = i + 1; } return (result); }
void ArcballHelper::update(Arcball const & arcball) { update_drag(arcball); update_constraints(arcball); update_result(arcball); update_rim(arcball); helpers = gst::Scene(eye); if (show_drag) { helpers.add(drag_node); } if (show_rim) { helpers.add(rim_node); } if (show_result) { helpers.add(result_node); } if (show_constraints) { for (auto node : constraint_nodes) { helpers.add(node); } } helpers.update(); }
void Analyzer_Position_Estimate_Divergence::evaluate_estimate( const std::string name, AnalyzerVehicle::Position position, AnalyzerVehicle::Position estimate) { if (estimate.lat_modtime() == 0) { // No estimate for this yet return; } double delta = estimate.horizontal_distance_to(position); bool failing = (delta > delta_warn()); // ::fprintf(stderr, "%s: delta=%f delta_warn=%f: %s\n", name.c_str(), delta, delta_warn(), failing ? "FAILING" : ""); if (_result.count(name) == 0 || _result[name] == NULL) { // no current problem if (failing) { open_result(name, delta); } } else { // problem currently underway if (failing) { update_result(name, delta); } else { close_result(name); } } }
void Analyzer_Attitude_Estimate_Divergence::evaluate_estimate( std::string name, AnalyzerVehicle::Attitude attitude, AnalyzerVehicle::Attitude estimate) { if (estimate.roll_modtime() == 0) { // No estimate for this yet return; } double delta_roll = fabs(angle_delta(estimate.roll(), attitude.roll())); double delta_pitch = fabs(angle_delta(estimate.pitch(), attitude.pitch())); // double delta_yaw = estimate.yaw() - attitude.yaw(); double delta = delta_roll > delta_pitch ? delta_roll : delta_pitch; bool failing = (delta >= delta_warn()); if (_result[name] == NULL) { if (failing) { open_result(name, delta); } } else { if (failing) { update_result(name, delta); } else { close_result(name); } } }
void Dialog::on_pushButton_sync_data_released() { if(!check_if_can_run(false)) return; QString android_product_out = target_product_path; if(QDir(android_product_out).exists()) { int ret = backup::do_cmd_return_str("adb -p " + android_product_out + " sync data 2>&1", ui->textEdit_result); if(ret != 0) update_result(msg_alert, "Sync data Failed!\n"); else update_result(msg_succeed, "Sync data Succeed!\n"); } else update_result(msg_alert, "No such file or directory!\n"); }
void Analyzer_Position_Estimate_Divergence::open_result(const std::string name, double delta) { _result[name] = new Analyzer_Position_Estimate_Divergence_Result(name); _result[name]->set_reason("This position estimate differs from the canonical craft position"); _result[name]->set_T_start(_vehicle->T()); _result[name]->set_max_delta(0); _result[name]->add_source(_data_sources.get("POSITION")); _result[name]->add_source(_data_sources.get(std::string("POSITION_ESTIMATE_") + name)); update_result(name, delta); }
void SendWork() { while (isRunning) { auto item = SendQueue.GetFrontAndPop(); pthread_t ptid = pthread_self(); FM_LOG_TRACE("Send thread id: %d", ptid); if (item.first == EXIT_OK) { update_result(item.second); } else { update_system_error(item.first, item.second); } } }
// update vold.bin void Dialog::on_pushButton_update_vold_released() { if(!check_if_can_run(true)) return; if(QFile(framework_jar_absolute_path).exists()) { int ret = backup::do_cmd_return_str(get_cmd_update_vold_bin(), ui->textEdit_result); if(ret != 0) update_result(msg_alert, "Update vold Failed!\n"); else { // restart vold backup::do_cmd_return_str("adb shell setprop ctl.stop vold && adb shell setprop ctl.start vold 2>&1", ui->textEdit_result); update_result(msg_succeed, "Update vold Succeed!\n"); } } else { update_result(msg_alert, "No such file or directory!\n"); } }
int my_cmd_next(db_res_t* res) { int ret; struct my_cmd* mcmd; mcmd = DB_GET_PAYLOAD(res->cmd); if (mcmd->next_flag == 2 || mcmd->next_flag == -2) return 1; if (mcmd->st == NULL) { ERR("mysql: Prepared statement not found\n"); return -1; } ret = mysql_stmt_fetch(mcmd->st); if (ret == MYSQL_NO_DATA) { mcmd->next_flag = mcmd->next_flag<0?-2:2; return 1; } /* MYSQL_DATA_TRUNCATED is only defined in mysql >= 5.0 */ #if defined MYSQL_DATA_TRUNCATED if (ret == MYSQL_DATA_TRUNCATED) { int i; ERR("mysql: mysql_stmt_fetch, data truncated, fields: %d\n", res->cmd->result_count); for (i = 0; i < res->cmd->result_count; i++) { if (mcmd->st->bind[i].error /*&& mcmd->st->bind[i].buffer_length*/) { ERR("mysql: truncation, bind %d, length: %lu, buffer_length: %lu\n", i, *(mcmd->st->bind[i].length), mcmd->st->bind[i].buffer_length); } } ret = 0; } #endif if (mcmd->next_flag <= 0) { mcmd->next_flag++; } if (ret != 0) { ERR("mysql: Error in mysql_stmt_fetch (ret=%d): %s\n", ret, mysql_stmt_error(mcmd->st)); return -1; } if (update_result(res->cmd->result, mcmd->st) < 0) { mysql_stmt_free_result(mcmd->st); return -1; } res->cur_rec->fld = res->cmd->result; return 0; }
void Analyzer_Velocity_Estimate_Divergence::evaluate_estimate( const std::string name, AnalyzerVehicle::Velocity &velocity, AnalyzerVehicle::Velocity &estimate) { if (estimate.velocity_modtime() == 0) { // No estimate for this yet return; } // make sure we're comparing apples with apples: double velocity_size; if (estimate.is_2d()) { velocity_size = velocity.size_2d(); } else { velocity_size = velocity.size(); } double delta = estimate.size() - velocity_size; // ::fprintf(stderr, "delta: %f\n", delta); bool failing = (delta > delta_warn()); // ::fprintf(stderr, "%s: delta=%f delta_warn=%f: %s\n", name.c_str(), delta, delta_warn(), failing ? "FAILING" : ""); if (_result.count(name) == 0 || _result[name] == NULL) { // no current problem if (failing) { open_result(name, delta); } } else { // problem currently underway if (failing) { update_result(name, delta); } else { close_result(name); } } }
void E_scene_main_game::player_do_a_move(char promotion) { // Inform FAILE of the move char piece_pos[6]; piece_pos[0]=(char)('h'-SquareXSelected); // from piece_pos[1]=(char)(SquareZSelected+'1'); // from piece_pos[2]=(char)('h'-FutureXSquare); // target piece_pos[3]=(char)(FutureZSquare+'1'); // target piece_pos[4]=promotion; // promotion piece_pos[5]=0; Player_do_a_move(piece_pos); // Update the graphical interface chessboard->Move_piece(SquareXSelected+8*SquareZSelected,FutureXSquare+8*FutureZSquare); if (game_mode == PLAYER_VS_PLAYER) { update_result(); if (result!=no_result) { game_is_over=true; pGlobalInfos->GUI_displayResult(result); } } SquareXSelected=-1; SquareZSelected=-1; FutureXSquare=-1; FutureZSquare=-1; if (current_color == WHITE) current_color = BLACK; else current_color = WHITE; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); connect(ui->actionBackground, SIGNAL(triggered()), this, SLOT(background_file_open())); connect(ui->actionClosed_Aperature, SIGNAL(triggered()), this, SLOT(closedapp_file_open())); connect(ui->actionImage_Stack, SIGNAL(triggered()), this, SLOT(imagelist_file_open())); connect(ui->actionRun_Experiment, SIGNAL(triggered()), this, SLOT(run_experiment())); set_background = false; set_closed = false; set_image_list = false; ui->actionClosed_Aperature->setDisabled(true); ui->actionImage_Stack->setDisabled(true); ui->actionRun_Experiment->setDisabled(true); ui->actionShow_Graph->setDisabled(true); frapmodel = new FrapModel(0); connect(this,SIGNAL(primaset(QString)),frapmodel,SLOT(setPrima(QString))); connect(this,SIGNAL(closedset(QString)),frapmodel,SLOT(setClosed(QString))); connect(this,SIGNAL(doselection()),frapmodel,SLOT(doSelection())); connect(this,SIGNAL(imagelistset(QStringList)),frapmodel,SLOT(setImageList(QStringList))); connect(ui->actionShow_Graph, SIGNAL(triggered()),frapmodel, SLOT(prepareLinearFit())); //connect(frapmodel,SIGNAL(dataChanged(QModelIndex,QModelIndex)), ui->tableView,SLOT(dataChanged(QModelIndex,QModelIndex))); connect(frapmodel,SIGNAL(update_result(QString)), this, SLOT(show_result(QString))); connect(frapmodel,SIGNAL(plotLinearFit(int,std::vector<double>&,std::vector<double>&,std::vector<double>&,double,double)), ui->pl_widget, SLOT(plotLinearFit(int,std::vector<double>&,std::vector<double>&,std::vector<double>&,double,double))); ui->tabWidget->setCurrentIndex(0); starting_dir = "/home/jon/Programming/C/frap-tool-old"; }
// ----------------------------------------------------------------------------- int QALSH::knn( // k-nn search float* query, // query point int top_k, // top-k value ResultItem* rslt, // k-nn results char* output_folder) // output folder { // ------------------------------------------------------------------------- // Space allocation and initialization // ------------------------------------------------------------------------- // init k-nn results for (int i = 0; i < top_k; i++) { rslt[i].id_ = -1; rslt[i].dist_ = MAXREAL; } // objects frequency int* frequency = new int[n_pts_]; for (int i = 0; i < n_pts_; i++) { frequency[i] = 0; } // whether an object is checked bool* is_checked = new bool[n_pts_]; for (int i = 0; i < n_pts_; i++) { is_checked[i] = false; } float* data = new float[dim_]; // one object data for (int i = 0; i < dim_; i++) { data[i] = 0.0f; } g_memory += ((SIZEBOOL + SIZEINT) * n_pts_ + SIZEFLOAT * dim_); bool* flag = new bool[m_]; // whether a hash table is finished for (int i = 0; i < m_; i++) { flag[i] = true; } float* q_val = new float[m_]; // hash value of query for (int i = 0; i < m_; i++) { q_val[i] = -1.0f; } g_memory += (SIZEFLOAT + SIZEBOOL) * m_; // left and right page buffer PageBuffer* lptr = new PageBuffer[m_]; PageBuffer* rptr = new PageBuffer[m_]; g_memory += (SIZECHAR * B_ * m_ * 2 + SIZEINT * m_ * 6); for (int i = 0; i < m_; i++) { lptr[i].leaf_node_ = NULL; lptr[i].index_pos_ = -1; lptr[i].leaf_pos_ = -1; lptr[i].size_ = -1; rptr[i].leaf_node_ = NULL; rptr[i].index_pos_ = -1; rptr[i].leaf_pos_ = -1; rptr[i].size_ = -1; } // ------------------------------------------------------------------------- // Compute hash value <q_dist> of query and init the page buffers // <lptr> and <rptr>. // ------------------------------------------------------------------------- page_io_ = 0; // num of page i/os dist_io_ = 0; // num of dist cmpt init_buffer(lptr, rptr, q_val, query); // ------------------------------------------------------------------------- // Determine the basic <radius> and <bucket_width> // ------------------------------------------------------------------------- float radius = find_radius(lptr, rptr, q_val); float bucket_width = (w_ * radius / 2.0f); // ------------------------------------------------------------------------- // K-nn search // ------------------------------------------------------------------------- bool again = true; // stop flag int candidates = 99 + top_k; // threshold of candidates int flag_num = 0; // used for bucket bound int scanned_id = 0; // num of scanned id int checked=0; int id = -1; // current object id int count = -1; // count size in one page int start = -1; // start position int end = -1; // end position float left_dist = -1.0f; // left dist with query float right_dist = -1.0f; // right dist with query float knn_dist = MAXREAL; // kth nn dist // result entry for update ResultItem* item = new ResultItem(); g_memory += (long) sizeof(ResultItem); while (again) { // --------------------------------------------------------------------- // Step 1: initialize the stop condition for current round // --------------------------------------------------------------------- flag_num = 0; for (int i = 0; i < m_; i++) { flag[i] = true; } // --------------------------------------------------------------------- // Step 2: find frequent objects // --------------------------------------------------------------------- while (true) { for (int i = 0; i < m_; i++) { if (!flag[i]) continue; // ------------------------------------------------------------- // Step 2.1: compute <left_dist> and <right_dist> // ------------------------------------------------------------- left_dist = -1.0f; if (lptr[i].size_ != -1) { left_dist = calc_proj_dist(&lptr[i], q_val[i]); } right_dist = -1.0f; if (rptr[i].size_ != -1) { right_dist = calc_proj_dist(&rptr[i], q_val[i]); } // ------------------------------------------------------------- // Step 2.2: determine the closer direction (left or right) // and do collision counting to find frequent objects. // // For the frequent object, we calc the L2 distance with // query, and update the k-nn result. // ------------------------------------------------------------- if (left_dist >= 0 && left_dist < bucket_width && ((right_dist >= 0 && left_dist <= right_dist) || right_dist < 0)) { count = lptr[i].size_; end = lptr[i].leaf_pos_; start = end - count; for (int j = end; j > start; j--) { id = lptr[i].leaf_node_->get_entry_id(j); frequency[id]++; scanned_id++; if (frequency[id] > l_ && !is_checked[id]) { is_checked[id] = true; read_data(id, dim_, B_, data, output_folder); item->dist_ = calc_l2_dist(data, query, dim_); item->id_ = id; knn_dist = update_result(rslt, item, top_k); checked++; // ------------------------------------------------- // Terminating condition 2 // ------------------------------------------------- dist_io_++; if (dist_io_ >= candidates) { again = false; flag_num += m_; break; } } } update_left_buffer(&lptr[i], &rptr[i]); } else if (right_dist >= 0 && right_dist < bucket_width && ((left_dist >= 0 && left_dist > right_dist) || left_dist < 0)) { count = rptr[i].size_; start = rptr[i].leaf_pos_; end = start + count; for (int j = start; j < end; j++) { id = rptr[i].leaf_node_->get_entry_id(j); frequency[id]++; scanned_id++; if (frequency[id] > l_ && !is_checked[id]) { is_checked[id] = true; read_data(id, dim_, B_, data, output_folder); item->dist_ = calc_l2_dist(data, query, dim_); item->id_ = id; knn_dist = update_result(rslt, item, top_k); checked++; // ------------------------------------------------- // Terminating condition 2 // ------------------------------------------------- dist_io_++; if (dist_io_ >= candidates) { again = false; flag_num += m_; break; } } } update_right_buffer(&lptr[i], &rptr[i]); } else { flag[i] = false; flag_num++; } if (flag_num >= m_) break; } if (flag_num >= m_) break; } // --------------------------------------------------------------------- // Terminating condition 1 // --------------------------------------------------------------------- if (knn_dist < appr_ratio_ * radius && dist_io_ >= top_k) { again = false; break; } // --------------------------------------------------------------------- // Step 3: auto-update <radius> // --------------------------------------------------------------------- radius = update_radius(lptr, rptr, q_val, radius); bucket_width = radius * w_ / 2.0f; } // ------------------------------------------------------------------------- // Release space // ------------------------------------------------------------------------- if (data != NULL || frequency != NULL || is_checked != NULL) { delete[] data; data = NULL; delete[] frequency; frequency = NULL; delete[] is_checked; is_checked = NULL; g_memory -= ((SIZEBOOL + SIZEINT) * n_pts_ + SIZEFLOAT * dim_); } if (q_val != NULL || flag != NULL || item != NULL) { delete[] q_val; q_val = NULL; delete[] flag; flag = NULL; delete item; item = NULL; g_memory -= (SIZEFLOAT + SIZEBOOL) * m_; g_memory -= (long) sizeof(ResultItem); } for (int i = 0; i < m_; i++) { // --------------------------------------------------------------------- // CANNOT remove the condition // <lptrs[i].leaf_node != rptrs[i].leaf_node> // Because <lptrs[i].leaf_node> and <rptrs[i].leaf_node> may point // to the same address, then we would delete it twice and receive // the runtime error or segmentation fault. // --------------------------------------------------------------------- if (lptr[i].leaf_node_ && lptr[i].leaf_node_ != rptr[i].leaf_node_) { delete lptr[i].leaf_node_; lptr[i].leaf_node_ = NULL; } if (rptr[i].leaf_node_) { delete rptr[i].leaf_node_; rptr[i].leaf_node_ = NULL; } } delete[] lptr; lptr = NULL; delete[] rptr; rptr = NULL; g_memory -= (SIZECHAR * B_ * m_ * 2 + SIZEINT * m_ * 6); return (page_io_ + dist_io_); }
void Dialog::err_log(const QString info) { update_result(msg_alert, info); }