/* * update classification (assignment) by calculated mean vectors. */ static void update_r(myvector inputs, int dim, int N, int k, myvector mean, int *r) { int i, klass; for (i = 0; i < N; i++) { float8 dist; float8 curr_dist; int curr_klass; curr_dist = calc_distance(&inputs[i * dim], &mean[0], dim); curr_klass = 0; /* * Search the nearst mean point. */ for (klass = 1; klass < k; klass++) { dist = calc_distance(&inputs[i * dim], &mean[klass * dim], dim); if (dist < curr_dist) { curr_dist = dist; curr_klass = klass; } } #ifdef KMEANS_DEBUG elog(LOG, "r[%d] = %d -> %d", i, r[i], curr_klass); #endif r[i] = curr_klass; } }
//------------------------------------------------------------------------ bool scale_ctrl_impl::on_mouse_button_down(double x, double y) { inverse_transform_xy(&x, &y); double xp1 = m_xs1 + (m_xs2 - m_xs1) * m_value1; double xp2 = m_xs1 + (m_xs2 - m_xs1) * m_value2; double ys1 = m_y1 - m_border_extra / 2.0; double ys2 = m_y2 + m_border_extra / 2.0; double yp = (m_ys1 + m_ys2) / 2.0; if(x > xp1 && y > ys1 && x < xp2 && y < ys2) { m_pdx = xp1 - x; m_move_what = move_slider; return true; } if(x < xp1 && calc_distance(x, y, xp1, yp) <= m_y2 - m_y1) { m_pdx = xp1 - x; m_move_what = move_value1; return true; } if(x > xp2 && calc_distance(x, y, xp2, yp) <= m_y2 - m_y1) { m_pdx = xp2 - x; m_move_what = move_value2; return true; } return false; }
//------------------------------------------------------------------------ bool gamma_ctrl_impl::on_mouse_button_down(double x, double y) { inverse_transform_xy(&x, &y); calc_points(); if(calc_distance(x, y, m_xp1, m_yp1) <= m_point_size + 1) { m_mouse_point = 1; m_pdx = m_xp1 - x; m_pdy = m_yp1 - y; m_p1_active = true; return true; } if(calc_distance(x, y, m_xp2, m_yp2) <= m_point_size + 1) { m_mouse_point = 2; m_pdx = m_xp2 - x; m_pdy = m_yp2 - y; m_p1_active = false; return true; } return false; }
fixed OLCSISAT::calc_score() const { // build convex hull from solution SearchPointVector spv; for (unsigned i = 0; i < num_stages; ++i) spv.push_back(solution[i]); prune_interior(spv); // now add leg distances making up the convex hull fixed G = fixed_zero; if (spv.size() > 1) { for (unsigned i = 0; i + 1 < spv.size(); ++i) G += spv[i].distance(spv[i + 1].get_location()); // closing leg (end to start) G += spv[spv.size() - 1].distance(spv[0].get_location()); } // R distance (start to end) const fixed R = solution[0].distance(solution[num_stages - 1].get_location()); // V zigzag-free distance const fixed V = G - R; // S = total distance const fixed S = calc_distance(); return apply_handicap((V + fixed(3) * S) * fixed(0.00025)); }
int main(void) { int i,j double distance,max_distance; point point_t[5]; for (i=0 ;i<5 ;i++ ) { scanf("%d,%d",&(point_t[i].x),&(point_t[i].y)); } max_distance=0; for (i=0 ;i<5 ;i++ ) { for (j=0 ;j<5 ;j++ ) { distance=calc_distance(point_t[i],point_t[j]); if (distance>max_distance) { max_distance=distance; printf("%d,%d and %d,%d",point_t[i].x,point_t[i].y,point_t[j].x,point_t[j].y); } } } return 0; }
int check_location(pam_handle_t *pamh, struct options *opts, char *location_string, struct locations *geo) { struct locations *list; struct locations *loc; double distance; list = loc = parse_locations(pamh, opts, location_string); while (list) { if (list->country == NULL) { if (strcmp(geo->country, "UNKNOWN") == 0) { list = list->next; continue; } if (opts->is_city_db) { distance = calc_distance(list->latitude, list->longitude, geo->latitude, geo->longitude); if (distance <= list->radius) { pam_syslog(pamh, LOG_INFO, "distance(%.3f) < radius(%3.f)", distance, list->radius); sprintf(location_string, "%.3f {%f,%f}", distance, geo->latitude, geo->longitude); free_locations(loc); return 1; } } else pam_syslog(pamh, LOG_INFO, "not a city db edition, ignoring distance entry"); } else { if (opts->debug) pam_syslog(pamh, LOG_INFO, "location: (%s,%s) geoip: (%s,%s)", list->country, list->city, geo->country, geo->city); if ( (list->country[0] == '*' || strcmp(list->country, geo->country) == 0) && (list->city[0] == '*' || strcmp(list->city, geo->city ) == 0) ) { if (opts->debug) pam_syslog(pamh, LOG_INFO, "location [%s,%s] matched: %s,%s", geo->country, geo->city, list->country, list->city); sprintf(location_string, "%s,%s", geo->country, geo->city); free_locations(loc); return 1; } } list = list->next; } if (loc) /* may be NULL */ free_locations(loc); return 0; }
/* This moves an individual fly torwards another */ static int move_fly(ffly *fly, ffly *old, const size_t nparams, const double alpha, const double gamma, const double mins[], const double maxs[]) { size_t i = 0; int moved = 0; const double beta0 = BETA_ZERO; //base attraction if (fly->val > old->val) { //get the distance to the other fly double r = calc_distance(fly, old, nparams); //determine attractiveness with air density [gamma] double beta = beta0 * exp((-gamma) * pow(r, 2.0)); beta = (beta < BETA_MIN) ? BETA_MIN : beta; //adjust position with a small random step for (i = 0; i < nparams; i++) { double val = fly->params[i] + (beta * (old->params[i] - fly->params[i])) + (alpha * (drand48() - 0.5)); //keep within bounds fly->params[i] = (val < mins[i]) ? mins[i] : (val > maxs[i]) ? maxs[i] : val; } moved = 1; } return moved; };
void points::set_max_r(void) { for (int i = 0; i < NUM; i++) { int to = Points[i].get_to_idx(); double dist = calc_distance(Points[i], Points[to]); if (max_r < dist) max_r = dist; } }
// if has a player in proximity, return this player's index // else return -1 int find_best_player_to_pass(int direction){ int i; extern int ball[2], kickpower; extern int teaminfo[NUM_PLAYERS][5]; // distance is measured between me and the other player, location is the coordinates of the other player int distance, location[2]; int best_thus_far = -1, best_dribb = -1; for (i=0; i<NUM_PLAYERS; i++) { location[0] = teaminfo[i][INFO_XCOORD]; // xcoord location[1] = teaminfo[i][INFO_YCOORD]; // ycoord distance = calc_distance(player.newlocation, location); if (direction == KICKLEFT) { if (location[0] < player.newlocation[0] && distance <= kickpower*2 && best_dribb < teaminfo[i][INFO_DRIBB]) { //get the best player with highest dribbling skill best_thus_far = i; best_dribb = teaminfo[i][INFO_DRIBB]; } } if (direction == KICKRIGHT) { if (location[0] > player.newlocation[0] && distance <= kickpower*2 && best_dribb < teaminfo[i][INFO_DRIBB]) { //get the best player with highest dribbling skill best_thus_far = i; best_dribb = teaminfo[i][INFO_DRIBB]; } } } return best_thus_far; }
void waypointspath_control::waypoints_autopath(){ commcount = coilchange_track = jiggle_track= 0; qDebug() << "Waypoints control thread running"; //qDebug() << " Command entered : " << command; command = start_command; command_x = command_y = start_command; TimeDelay(1000); if(w->clicks) { CString comport = "\\\\.\\COM4"; w->serialHandle = CreateFile(comport, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); if(w->serialHandle == INVALID_HANDLE_VALUE) emit autopath_finished(); DCB serialParams = { 0 }; serialParams.DCBlength = sizeof(serialParams); GetCommState(w->serialHandle, &serialParams); serialParams.BaudRate = 9600; serialParams.ByteSize = 8; serialParams.StopBits = ONESTOPBIT; serialParams.Parity = PARITY_NONE; GetCommState(w->serialHandle, &serialParams); // Set timeouts COMMTIMEOUTS timeout = { 0 }; timeout.ReadIntervalTimeout = 50; timeout.ReadTotalTimeoutConstant = 50; timeout.ReadTotalTimeoutMultiplier = 50; timeout.WriteTotalTimeoutConstant = 50; timeout.WriteTotalTimeoutMultiplier = 10; SetCommTimeouts(w->serialHandle, &timeout); COM = w->COM; for(int l = 1; l <= cycles_no; l++){ for(wayptno = 0; wayptno < w->clicks; wayptno++){ prevdist = calc_distance(w->waypoints[wayptno]); xdist = std::abs(COM.x - w->waypoints[wayptno].x * conv_factor[0]); ydist = std::abs(COM.y - w->waypoints[wayptno].y * conv_factor[1]); prevangle = w->angle; COMprev = w->COM; while(wayptno < w->clicks && sqrt(pow(std::abs(w->COM.x - w->waypoints[wayptno].x),2) + pow(std::abs(w->COM.y - w->waypoints[wayptno].y),2)) > tolerance) { //data_command = determine_command(COM,waypoints,l); commcount++; //data_command[3] = 0xaa; determine_command(wayptno); //WriteFile(w->serialHandle,(LPCVOID)data_command, toBeWritten, written,NULL); qDebug() << "Check state waypoint control : "<< WriteFile(w->serialHandle,(LPVOID)data_command, toBeWritten, written,NULL); TimeDelay(1000); if(!WriteFile(w->serialHandle,(LPCVOID)w->prevsent,toBeWritten, written, NULL)); emit autopath_finished(); TimeDelay(100); //for(int i = 0; i < 7; i++) //data_command[i] = 0x00; } } } } CloseHandle(w->serialHandle); emit autopath_finished(); }
Pixel rad_dot(const Ink *inky, const SHORT x, const SHORT y) /* This one is so slow don't bother to have a hline routine... */ { if(vl.rgr == 0) /* can't be zero */ vl.rgr = 1; return(dfrom_range(calc_distance(x,y,vl.rgc.x,vl.rgc.y)%vl.rgr, vl.rgr,x,y,inky->dither)); }
void MimRec::calcForTrainingData(const cv::Mat& trackingPoints, const std::string& outputFilePath, const cv::Mat fittingImage) { currentPoints = trackingPoints; areaFace(); calc_distance(); normalizeDistances(); calcIntensityScoring(outputFilePath, fittingImage); }
double get_sub_min_distance( struct point* points, int dest_point_count, int* dest_point_index, int point_count, int light_range ) { int i; char point_is_added[point_count]; double low_cost[point_count]; memset(point_is_added, 0, point_count); for (i = 0; i < point_count; ++i) { low_cost[i] = INF; } int num = 0; int e = dest_point_index[0]; point_is_added[e] = 1; double distance = 0; while (++num < dest_point_count) { double min_distance = INF; int min_edge = -1; int idx; for (idx = 0; idx < dest_point_count; ++idx) { int i = dest_point_index[idx]; if (point_is_added[i]) { continue; } double cur_cost = calc_distance(points + i, points + e, light_range); if (cur_cost < low_cost[i]) { low_cost[i] = cur_cost; } if (low_cost[i] < min_distance) { min_edge = i; min_distance = low_cost[i]; } LOG("i=%d e=%d low_cost:%lf\n", i, e, low_cost[i]); } distance += min_distance; e = min_edge; point_is_added[e] = 1; LOG("%d cur distance:%lf\n", e, distance); //++num; } return distance; }
void calc_all_distances(int dim, int n, int k, double *X, double *centroid, double *distance_output) { for (int ii = 0; ii < n; ii++) // for each point for (int jj = 0; jj < k; jj++) // for each cluster { // calculate distance between point and cluster centroid distance_output[ii*k + jj] = calc_distance(dim, &X[ii*dim], ¢roid[jj*dim]); } }
double points::config_score(void) { double score = 0.0; for (int i = 0; i < NUM; i++) { int to = Points[i].get_to_idx(); double dist = calc_distance(Points[i], Points[to]); score += dist; } cout << "score: " << score << endl; return score; }
/* * Evaluation function. kmeans tries to minimize value of this function. */ static float8 J(myvector inputs, int dim, int N, int k, myvector mean, int *r) { int i; float8 sum = 0.0; for (i = 0; i < N; i++) { sum += calc_distance(&inputs[i * dim], &mean[r[i] * dim], dim); } return sum; }
fixed XContestTriangle::calc_score() const { // DHV-XC: 2.0 or 1.75 points per km for FAI vs non-FAI triangle // XContest: 1.4 or 1.2 points per km for FAI vs non-FAI triangle const fixed score_factor = is_dhv? (is_fai? fixed(0.002): fixed(0.00175)) :(is_fai? fixed(0.0014): fixed(0.0012)); return apply_handicap(calc_distance()*score_factor); }
double path_length(VertexSource& vs, unsigned path_id = 0) { double len = 0.0; double start_x = 0.0; double start_y = 0.0; double x1 = 0.0; double y1 = 0.0; double x2 = 0.0; double y2 = 0.0; bool first = true; unsigned cmd; vs.rewind(path_id); while(!is_stop(cmd = vs.vertex(&x2, &y2))) { if(is_vertex(cmd)) { if(first || is_move_to(cmd)) { start_x = x2; start_y = y2; } else { len += calc_distance(x1, y1, x2, y2); } x1 = x2; y1 = y2; first = false; } else { if(is_close(cmd) && !first) { len += calc_distance(x1, y1, start_x, start_y); } } } return len; }
void SnakeClass::Snake_algorithm() { CPoint temp; Snake_points=pos; double max_curvature; int i; for(i=0; i<snake_point_num; i++) avg_distance+=calc_distance(i, Snake_points[i]); avg_distance=avg_distance/(double)snake_point_num; max_curvature=-1000000000.0; for(i=0; i<snake_point_num; i++) { temp=calc_min_energy(i,Snake_points[i],avg_distance); if(temp!=Snake_points[i] &&temp!=Snake_points[(i-1+snake_point_num)%snake_point_num] &&temp!=Snake_points[(i+1+snake_point_num)%snake_point_num]) { Snake_points[i]=temp; } curvature[i]=curvature_ene(i, Snake_points[i]); if(max_curvature<curvature[i]) max_curvature=curvature[i]; } avg_distance=0.0; //归一化各点曲率能量 for(i=0; i<snake_point_num; i++) curvature[i]=curvature[i]/max_curvature; for(i=0; i<snake_point_num; i++) { avg_distance+=calc_distance(i, Snake_points[i]); if(curvature[i]>threshold_curvature &&curvature[i]>curvature[(i+1)%snake_point_num] &&curvature[i]>curvature[(i-1+snake_point_num)%snake_point_num] &&grad_mag[i]>threshold_grad) *(beta+i)=0; } }
//------------------------------------------------------------------------ bool vcgen_contour::calc_miter(const vertex_dist& v0, const vertex_dist& v1, const vertex_dist& v2) { double dx1, dy1, dx2, dy2; dx1 = m_signed_width * (v1.y - v0.y) / v0.dist; dy1 = m_signed_width * (v1.x - v0.x) / v0.dist; dx2 = m_signed_width * (v2.y - v1.y) / v1.dist; dy2 = m_signed_width * (v2.x - v1.x) / v1.dist; double xi; double yi; if(!calc_intersection(v0.x + dx1, v0.y - dy1, v1.x + dx1, v1.y - dy1, v1.x + dx2, v1.y - dy2, v2.x + dx2, v2.y - dy2, &xi, &yi)) { m_x1 = v1.x + dx1; m_y1 = v1.y - dy1; return false; } else { double d1 = calc_distance(v1.x, v1.y, xi, yi); double lim = m_abs_width * m_miter_limit; if(d1 > lim) { d1 = lim / d1; m_x1 = v1.x + dx1; m_y1 = v1.y - dy1; m_x2 = v1.x + dx2; m_y2 = v1.y - dy2; m_x1 += (xi - m_x1) * d1; m_y1 += (yi - m_y1) * d1; m_x2 += (xi - m_x2) * d1; m_y2 += (yi - m_y2) * d1; return true; } else { m_x1 = xi; m_y1 = yi; } } return false; }
int points::nearest_nei(int curr_idx) { double min_dist = 9999.0; int nearest_nei_idx; for (int i = 0; i < NUM; i++) { if (i == curr_idx) continue; double dist = calc_distance(Points[i], Points[curr_idx]); if (dist < min_dist) { min_dist = dist; nearest_nei_idx = i; } } if (max_r < min_dist) max_r = min_dist; return nearest_nei_idx; }
MimRec::MimRec(const TrainingData& neutral) { currentPoints = neutral.getPoints(); vAUDetectionValue.resize(actionUnits.size()); vBackPropAUDetectionValue.resize(actionUnits.size()); areaFace(); calc_distance(); neutral_area = areas; neutral_distances.swap(current_distances); }
/* Triangle initialization */ static int triangle_init() { point_2d a, b, c; // hard coded values for testing : X1 = 15; Y1 = 15; X2 = 23; Y2 = 30; X3 = 50; Y3 = 25; a = (point_2d){.x = X1, .y = Y1}; b = (point_2d){.x = X2, .y = Y2}; c = (point_2d){.x = X3, .y = Y3}; given_triangle.A = a; given_triangle.B = b; given_triangle.C = c; given_triangle.side_a = calc_distance(&c, &b); given_triangle.side_b = calc_distance(&a, &c); given_triangle.side_c = calc_distance(&a, &b); return is_triangle_possible(&given_triangle); }
//------------------------------------------------------------------------ bool slider_ctrl_impl::on_mouse_button_down(double x, double y) { inverse_transform_xy(&x, &y); double xp = m_xs1 + (m_xs2 - m_xs1) * m_value; double yp = (m_ys1 + m_ys2) / 2.0; if(calc_distance(x, y, xp, yp) <= m_y2 - m_y1) { m_pdx = xp - x; m_mouse_move = true; return true; } return false; }
static Errcode make_circle_mask(int tscale0,int tscale1,Pframedat *pfd) { Rcel *dest = pfd->dest; int radius; int cenx; int ceny; (void)tscale0; cenx = dest->width/2; ceny = dest->height/2; radius = (tscale1 * (5+calc_distance(0,0,cenx,ceny)))/SCALE_ONE; pj_set_rast(dest,pfd->invert); circle(dest,!pfd->invert, cenx, ceny, radius<<1, TRUE); return(Success); }
//------------------------------------------------------------------------ bool rbox_ctrl_impl::on_mouse_button_down(real x, real y) { inverse_transform_xy(&x, &y); unsigned i; for(i = 0; i < m_num_items; i++) { real xp = m_xs1 + m_dy / 1.3; real yp = m_ys1 + m_dy * i + m_dy / 1.3; if(calc_distance(x, y, xp, yp) <= m_text_height / 1.5) { m_cur_item = int(i); return true; } } return false; }
bool AbstractContest::save_solution() { const fixed score = calc_score(); const bool improved = (score>best_result.score); if (improved) { best_result.score = score; best_result.distance = calc_distance(); best_result.time = calc_time(); if (positive(best_result.time)) best_result.speed = best_result.distance / best_result.time; else best_result.speed = fixed_zero; return true; } return false; }
//------------------------------------------------------------------------ bool spline_ctrl_impl::on_mouse_button_down(double x, double y) { inverse_transform_xy(&x, &y); unsigned i; for(i = 0; i < m_num_pnt; i++) { double xp = calc_xp(i); double yp = calc_yp(i); if(calc_distance(x, y, xp, yp) <= m_point_size + 1) { m_pdx = xp - x; m_pdy = yp - y; m_active_pnt = m_move_pnt = int(i); return true; } } return false; }
double calc_total_distance(int dim, int n, int k, double *X, double *centroids, int *cluster_assignment_index) // NOTE: a point with cluster assignment -1 is ignored { double tot_D = 0; // for every point for (int ii = 0; ii < n; ii++) { // which cluster is it in? int active_cluster = cluster_assignment_index[ii]; // sum distance if (active_cluster != -1) tot_D += calc_distance(dim, &X[ii*dim], ¢roids[active_cluster*dim]); } return tot_D; }
bool AIManager::CheckEated(FoodName name, Ogre::Vector3 pos) { for (std::size_t m = 0; m < FoodEatlist[name].size(); m++ ) { AnimalName aniname = FoodEatlist[name][m]; for (std::size_t i = 0; i < mAnimalList[aniname].size(); i++ ) { if (calc_distance(mAnimalList[aniname][i]->getPosition(), pos) < 20000) //(mAnimalList[aniname][i]->getRadius() + 25)) { delete mAnimalList[aniname][i]; mAnimalList[aniname].erase(mAnimalList[aniname].begin()+i); return true; } } } return false; }