int find_closest(int start, int end)
{
int n = end - start + 1;
if (n <= 3)return find_in_total(start, end);
int mid = (start + end) / 2;
int min = find_closest(start, mid);
int d = find_closest(mid + 1, end);
min = MIN(min, d);
#if (DEBUG >= 2)
printf("start=%d, end=%d\n", start, end);
#endif //DEBUG
int i, j;
i = mid - 1;
int idx = 0;
while (DIST_X(point[i], point[mid]) <= min && i >= start) {
temp_point[idx++] = point[i];
i--;
}
i = mid + 1;
while (DIST_X(point[i], point[mid]) <= min && i <= end) {
temp_point[idx++] = point[i];
i++;
}
idx--;
quicksort(temp_point, 0, idx, BASE_Y);
for (i = 0; i <= idx - 1; i++) {
for (j = i + 1; j <= idx; j++) {
d = DIST_Y(temp_point[i], temp_point[j]);
if (d < min) {
d += DIST_X(temp_point[i], temp_point[j]);
min = MIN(min, d);
#if (DEBUG >= 1)
printf("i=%d, j=%d, (%d, %d) - (%d, %d) = %d\n",
i, j, temp_point[i].x, temp_point[i].y, temp_point[j].x, temp_point[j].y, min);
#endif //DEBUG
} else {
break;
}
}
}
return min;
}
t_color compute_light(t_scene *scene, t_ray *ray)
{
t_list *current;
t_ray lray;
t_color color[3];
t_phpa ph;
current = scene->lights;
ph.normal = get_normal(*ray);
set_ambiant_light(&ph, scene, ray, color);
while (current)
{
lray.pos = ((t_light *)current->content)->pos;
lray.dir = norm_vect(mtx_add(mtx_sub(mtx_mult(ray->dir, ray->t),
lray.pos), ray->pos));
lray.invdir = get_inv_vect(&lray.dir);
if (find_closest(scene, &lray) && ray->closest == lray.closest
&& near_enough(ray, &lray))
{
set_params(&ph, &lray, ray);
ph.camera = scene->camera;
ph.light = (t_light *)current->content;
phong(&ph);
}
current = current->next;
}
set_color_max(&ph);
return (*color);
}
void Peer::build_routing_table()
{
int const uuidSpace = sizeof(SylUtil::Uuid) * 8; //128-bit uuid space
SylUtil::Uuid upperLimit;
for (int i = 0; i < uuidSpace; ++i)
{
upperLimit.setBit(i);
SylUtil::Uuid distance;
distance.setBit(i);
SylUtil::Uuid closest;
SylUtil::Uuid closest_distance;
find_closest(m_uuid, distance, upperLimit, closest, closest_distance);
if (closest != m_uuid)
{
SylNet::Connection c = m_routingTable.at(closest);
m_handler.find_closest(distance, c);
}
find_closest_inverse(m_uuid, distance, closest, closest_distance);
if (closest != m_uuid)
{
SylNet::Connection c = m_routingTable.at(closest);
m_handler.try_join(distance, c); //Update the routing tables of other nodes in the overlay
}
}
m_routingTable.clear();
}
void compute_cluster_centers(Dataset* dataset, Centroid** centroids){
// Datapoint* random_point = dataset->points[rand() % dataset->size];
for (size_t i = 0; i < dataset->size; i++) {
Centroid* closest_centroid = find_closest(centroids, dataset->points[i]);
update_center(dataset, closest_centroid);
}
scramble_dataset(dataset);
}
font
smart_font_rep::get_math_font (string fam, string var, string ser, string sh) {
find_closest (fam, var, ser, sh);
string mvar= "mr";
if (var == "ss") mvar= "ms";
if (var == "tt") mvar= "mt";
return find_font (fam, mvar, ser, "", sz, dpi);
}
int main(int argc, char *argv[]) {
clock_t seq_clk = clock();
int numberOfTrainingPictures = atoi(argv[1]);
int ***trainingSet = (int ***)malloc(sizeof(int **) * NUM_PEOPLE);
for (int i=0; i<NUM_PEOPLE; i++) {
trainingSet[i] = alloc_2d_matrix(numberOfTrainingPictures, MAX_DECIMAL_VALUE);
}
//trainingSet is a 3d matrix now (person x image x histogramIndex )
double seq_time = clock() - seq_clk;
double parallel_clk = omp_get_wtime();
#pragma omp parallel
{
#pragma omp for
for (int i=0; i<NUM_PEOPLE; i++) {
char filename[256];
for (int j=0; j<numberOfTrainingPictures; j++) {
sprintf(filename, "images/%d.%d.txt", i+1, j+1);
int **image = read_pgm_file(filename, IMAGE_R, IMAGE_R);
create_histogram(trainingSet[i][j], image, IMAGE_R, IMAGE_W);
free(image);
}
}
}
int correct_answers = 0;
#pragma omp parallel
{
#pragma omp for reduction(+:correct_answers)
for (int i=0; i<NUM_PEOPLE; i++) {
for (int j=numberOfTrainingPictures; j<NUM_PICS_PER_PERSON; j++) {
int *test_histogram = (int *)malloc(sizeof(int) * MAX_DECIMAL_VALUE);
char filename[256];
sprintf(filename, "images/%d.%d.txt", i+1, j+1);
int **image = read_pgm_file(filename, IMAGE_R, IMAGE_R);
create_histogram(test_histogram, image, IMAGE_R, IMAGE_W);
int predicted = find_closest(trainingSet, NUM_PEOPLE, numberOfTrainingPictures, MAX_DECIMAL_VALUE, test_histogram) + 1;
printf("%s %d %d\n", filename+7, predicted, i+1);
if(i+1 == predicted) {
correct_answers++;
}
}
}
}
printf("Accuracy: %d correct answers for %d tests\n", correct_answers, NUM_PEOPLE * (NUM_PICS_PER_PERSON - numberOfTrainingPictures));
printf("Parallel time: %lf\n", omp_get_wtime() - parallel_clk);
printf("Sequential time: %lf\n", seq_time/CLOCKS_PER_SEC);
return 0;
}
CompactFrameID
TimeCache::get_parent(fawkes::Time time, std::string* error_str)
{
TransformStorage* p_temp_1 = NULL;
TransformStorage* p_temp_2 = NULL;
int num_nodes = find_closest(p_temp_1, p_temp_2, time, error_str);
if (num_nodes == 0) {
return 0;
}
return p_temp_1->frame_id;
}
void StatusStructure::remove_line(EndEvent* event, EventStructure& event_structure) {
auto deletion_position(find_closest(event->get_l()));
auto intersection(Point3D(0.f, 0.f, -1.f));
if (deletion_position > lines_.begin() && deletion_position < lines_.end()-1) {
intersection = (*(deletion_position - 1))->intersects(**(deletion_position+1));
if (intersection.get_z() != -1.f && intersection.get_y() > event->get_position().get_y())
event_structure.add_event(new IntersectionEvent(intersection, *(deletion_position - 1), *(deletion_position+1)));
}
lines_.erase(deletion_position);
}
void StatusStructure::swap(IntersectionEvent* event, EventStructure& event_structure) {
auto swap_left(find_closest(event->get_l1()));
auto swap_right(find_closest(event->get_l2()));
auto intersection_right(Point3D(0.f, 0.f, -1.f));
auto intersection_left(Point3D(0.f, 0.f, -1.f));
if (swap_right < lines_.end() - 1) {
intersection_right = event->get_l1()->intersects(**(swap_right + 1));
if (intersection_right.get_z() != -1.f && intersection_right.get_y() >= event->get_position().get_y())
event_structure.add_event(new IntersectionEvent(intersection_right, event->get_l1(), *(swap_right + 1)));
}
if (swap_left > lines_.begin()) {
intersection_left = event->get_l2()->intersects(**(swap_left - 1));
if (intersection_left.get_z() != -1.f && intersection_left.get_y() >= event->get_position().get_y())
event_structure.add_event(new IntersectionEvent(intersection_left, *(swap_left - 1), event->get_l2()));
}
auto tmp = *swap_left;
*swap_left = *swap_right;
*swap_right = tmp;
}
int main(void)
{
int N;
scanf("%d", &N);
int i;
for (i = 0; i < N; i++)
scanf("%d %d", &(point[i].x), &(point[i].y));
quicksort(point, 0, N - 1, BASE_X);
#if (DEBUG >= 1)
for (i = 0; i < N; i++)
printf("%d ==> (%d, %d)\n", i, point[i].x, point[i].y);
#endif //DEBUG
printf("%d\n", find_closest(0, N - 1));
return 0;
}
bool
TimeCache::get_data(fawkes::Time time, TransformStorage & data_out,
std::string* error_str)
{
TransformStorage* p_temp_1 = NULL;
TransformStorage* p_temp_2 = NULL;
int num_nodes = find_closest(p_temp_1, p_temp_2, time, error_str);
if (num_nodes == 0) {
return false;
} else if (num_nodes == 1) {
data_out = *p_temp_1;
} else if (num_nodes == 2) {
if( p_temp_1->frame_id == p_temp_2->frame_id) {
interpolate(*p_temp_1, *p_temp_2, time, data_out);
} else {
data_out = *p_temp_1;
}
}
return true;
}
void get_init_shift(Secat *cat1, int ncat1, Secat *cat2, int ncat2,
Pos *initshift)
{
int no_error = 1; /* Flag set to 0 on error */
float cx,cy; /* Cursor position */
char cchar='0'; /* Character returned by cursor command */
Pos cpos; /* Cursor position */
Secat bestmatch1; /* Closest match to cursor position in image 1 */
Secat bestmatch2; /* Closest match to cursor position in image 2 */
/*
* Get the desired position in image 1
*/
printf("---------------------------------------------------------------\n");
if(no_error) {
cx = 0.0;
cy = 0.0;
printf("\n");
printf("Find a compact object that is clearly detected in both images\n");
printf("Click the mouse on the object in the FIRST image\n");
cpgslct(1);
if(cpgcurs(&cx,&cy,&cchar)>0) {
printf("\nMouse clicked at: %7.2f %7.2f\n",cx,cy);
cpos.x = cx;
cpos.y = cy;
bestmatch1 = find_closest(cpos,cat1,ncat1);
printf("Position of closest match is: %7.2f %7.2f\n",
bestmatch1.x,bestmatch1.y);
markcatobj(bestmatch1);
}
else {
fprintf(stderr,"*** Invalid cursor input ***\n");
no_error = 0;
}
}
/*
* Now get position in image 2
*/
if(no_error) {
printf("\n Now click the mouse on the object in the SECOND image\n");
cpgslct(2);
if(cpgcurs(&cx,&cy,&cchar)>0) {
printf("\nMouse clicked at: %7.2f %7.2f\n",cx,cy);
cpos.x = cx;
cpos.y = cy;
bestmatch2 = find_closest(cpos,cat2,ncat2);
printf("Position of closest match is: %7.2f %7.2f\n\n",
bestmatch2.x,bestmatch2.y);
markcatobj(bestmatch2);
}
else {
fprintf(stderr,"*** Invalid cursor input ***\n");
no_error = 0;
}
}
/*
* Calculate x,y offsets from selected position in image 1
*/
printf("---------------------------------------------------------------\n");
if(no_error) {
initshift->x = bestmatch2.x - bestmatch1.x;
initshift->y = bestmatch2.y - bestmatch1.y;
printf("\nInital estimate of shift between images: %8.2f %8.2f\n",
initshift->x,initshift->y);
}
}
bool planning_service(path_planner::path_srv::Request &req, path_planner::path_srv::Response &res){
int size = req.map.info.width;
std::vector<node> solution;
std::vector<int> commands;
std::vector<double> vals;
visualization_msgs::Marker object_marker;
std::vector<geometry_msgs::Point> pos_list;
geometry_msgs::Point pos;
nav_msgs::OccupancyGrid Correct_Map_Msg;
Occupancy_Grid.resize(size*size,blue);
heading_map = req.heading;
matrix_res = req.map.info.resolution;
for(int i=0; i < size*size; i++)
Occupancy_Grid[i]=req.map.data[i];
Correct_Map_Msg.info=req.map.info;
Correct_Map_Msg.data=Occupancy_Grid;
map_pub.publish(Correct_Map_Msg);
solution = find_closest(req.x,req.y,Occupancy_Grid,req.goal);
convert_to_commands(solution,&commands,&vals);
res.commands=commands;
res.vals=vals;
res.size=vals.size();
object_marker.header.frame_id = "/mapping";
object_marker.header.stamp = ros::Time::now();
// Set the namespace and id for this marker. This serves to create a unique ID
// Any marker sent with the same namespace and id will overwrite the old one
object_marker.ns = "path";
object_marker.id = 0;
object_marker.type = visualization_msgs::Marker::CUBE_LIST;
// Set the marker action. Options are ADD and DELETE
object_marker.action = visualization_msgs::Marker::ADD;
// Set the pose of the marker. This is a full 6DOF pose relative to the frame/time specified in the header
object_marker.scale.x = matrix_res;
object_marker.scale.y = matrix_res;
object_marker.scale.z = matrix_res;
// Set the color -- be sure to set alpha to something non-zero!
object_marker.color.r = 0.0f;
object_marker.color.g = 0.0f;
object_marker.color.b = 1.0f;
object_marker.color.a = 1.0;
object_marker.pose.orientation.w=1.0;
object_marker.lifetime = ros::Duration();
for(int i=0; i<solution.size(); i++){
pos.x=solution[i].coords[0]*0.01;
pos.y=solution[i].coords[1]*0.01;
pos.z=0;
pos_list.push_back(pos);
}
object_marker.points=pos_list;
for(int i = 0 ; i < vals.size(); i++){
ROS_WARN("PLANNED PATH: (%d,%.2f)", commands[i], vals[i]);
}
path_pub.publish(object_marker);
return true;
}
inline Color
CurveGradient::color_func(const Point &point_, int quality, float supersample)const
{
Point origin=param_origin.get(Point());
Real width=param_width.get(Real());
std::vector<synfig::BLinePoint> bline(param_bline.get_list().begin(), param_bline.get_list().end());
Gradient gradient=param_gradient.get(Gradient());
bool loop=param_loop.get(bool());
bool zigzag=param_zigzag.get(bool());
bool perpendicular=param_perpendicular.get(bool());
bool fast=param_fast.get(bool());
Vector tangent;
Vector diff;
Point p1;
Real thickness;
Real dist;
float perp_dist;
bool edge_case = false;
if(bline.size()==0)
return Color::alpha();
else if(bline.size()==1)
{
tangent=bline.front().get_tangent1();
p1=bline.front().get_vertex();
thickness=bline.front().get_width();
}
else
{
float t;
Point point(point_-origin);
std::vector<synfig::BLinePoint>::const_iterator iter,next;
// Figure out the BLinePoints we will be using,
// Taking into account looping.
if(perpendicular)
{
next=find_closest(fast,bline,point,t,bline_loop,&perp_dist);
perp_dist/=curve_length_;
}
else // not perpendicular
{
next=find_closest(fast,bline,point,t,bline_loop);
}
iter=next++;
if(next==bline.end()) next=bline.begin();
// Setup the curve
etl::hermite<Vector> curve(
iter->get_vertex(),
next->get_vertex(),
iter->get_tangent2(),
next->get_tangent1()
);
// Setup the derivative function
etl::derivative<etl::hermite<Vector> > deriv(curve);
int search_iterations(7);
/*if(quality==0)search_iterations=8;
else if(quality<=2)search_iterations=10;
else if(quality<=4)search_iterations=8;
*/
if(perpendicular)
{
if(quality>7)
search_iterations=4;
}
else // not perpendicular
{
if(quality<=6)search_iterations=7;
else if(quality<=7)search_iterations=6;
else if(quality<=8)search_iterations=5;
else search_iterations=4;
}
// Figure out the closest point on the curve
if (fast)
t = curve.find_closest(fast, point,search_iterations);
// Calculate our values
p1=curve(t); // the closest point on the curve
tangent=deriv(t); // the tangent at that point
// if the point we're nearest to is at either end of the
// bline, our distance from the curve is the distance from the
// point on the curve. we need to know which side of the
// curve we're on, so find the average of the two tangents at
// this point
if (t<0.00001 || t>0.99999)
{
bool zero_tangent = (tangent[0] == 0 && tangent[1] == 0);
if (t<0.5)
{
if (iter->get_split_tangent_angle() || iter->get_split_tangent_radius() || zero_tangent)
{
// fake the current tangent if we need to
if (zero_tangent) tangent = curve(FAKE_TANGENT_STEP) - curve(0);
// calculate the other tangent
Vector other_tangent(iter->get_tangent1());
if (other_tangent[0] == 0 && other_tangent[1] == 0)
{
// find the previous blinepoint
std::vector<synfig::BLinePoint>::const_iterator prev;
if (iter != bline.begin()) (prev = iter)--;
else if (loop) (prev = bline.end())--;
else prev = iter;
etl::hermite<Vector> other_curve(prev->get_vertex(), iter->get_vertex(), prev->get_tangent2(), iter->get_tangent1());
other_tangent = other_curve(1) - other_curve(1-FAKE_TANGENT_STEP);
}
// normalise and sum the two tangents
tangent=(other_tangent.norm()+tangent.norm());
edge_case=true;
}
}
else
{
if (next->get_split_tangent_angle() || next->get_split_tangent_radius() || zero_tangent)
{
// fake the current tangent if we need to
if (zero_tangent) tangent = curve(1) - curve(1-FAKE_TANGENT_STEP);
// calculate the other tangent
Vector other_tangent(next->get_tangent2());
if (other_tangent[0] == 0 && other_tangent[1] == 0)
{
// find the next blinepoint
std::vector<synfig::BLinePoint>::const_iterator next2(next);
if (++next2 == bline.end())
{
if (loop) next2 = bline.begin();
else next2 = next;
}
etl::hermite<Vector> other_curve(next->get_vertex(), next2->get_vertex(), next->get_tangent2(), next2->get_tangent1());
other_tangent = other_curve(FAKE_TANGENT_STEP) - other_curve(0);
}
// normalise and sum the two tangents
tangent=(other_tangent.norm()+tangent.norm());
edge_case=true;
}
}
}
tangent = tangent.norm();
if(perpendicular)
{
tangent*=curve_length_;
p1-=tangent*perp_dist;
tangent=-tangent.perp();
}
else // not perpendicular
// the width of the bline at the closest point on the curve
thickness=(next->get_width()-iter->get_width())*t+iter->get_width();
}
if(perpendicular)
{
if(quality>7)
{
dist=perp_dist;
/* diff=tangent.perp();
const Real mag(diff.inv_mag());
supersample=supersample*mag;
*/
supersample=0;
}
else
{
diff=tangent.perp();
//p1-=diff*0.5;
const Real mag(diff.inv_mag());
supersample=supersample*mag;
diff*=mag*mag;
dist=(point_-origin - p1)*diff;
}
}
else // not perpendicular
{
if (edge_case)
{
diff=(p1-(point_-origin));
if(diff*tangent.perp()<0) diff=-diff;
diff=diff.norm()*thickness*width;
}
else
diff=tangent.perp()*thickness*width;
p1-=diff*0.5;
const Real mag(diff.inv_mag());
supersample=supersample*mag;
diff*=mag*mag;
dist=(point_-origin - p1)*diff;
}
if(loop)
dist-=floor(dist);
if(zigzag)
{
dist*=2.0;
supersample*=2.0;
if(dist>1)dist=2.0-dist;
}
if(loop)
{
if(dist+supersample*0.5>1.0)
{
float left(supersample*0.5-(dist-1.0));
float right(supersample*0.5+(dist-1.0));
Color pool(gradient(1.0-(left*0.5),left).premult_alpha()*left/supersample);
if (zigzag) pool+=gradient(1.0-right*0.5,right).premult_alpha()*right/supersample;
else pool+=gradient(right*0.5,right).premult_alpha()*right/supersample;
return pool.demult_alpha();
}
if(dist-supersample*0.5<0.0)
{
float left(supersample*0.5-dist);
float right(supersample*0.5+dist);
Color pool(gradient(right*0.5,right).premult_alpha()*right/supersample);
if (zigzag) pool+=gradient(left*0.5,left).premult_alpha()*left/supersample;
else pool+=gradient(1.0-left*0.5,left).premult_alpha()*left/supersample;
return pool.demult_alpha();
}
}
return gradient(dist,supersample);
}
font
smart_font_rep::get_cyrillic_font (string fam, string var, string ser, string sh) {
find_closest (fam, var, ser, sh);
return find_font ("cyrillic", var, ser, sh, sz, dpi);
}
void menuFunction(KdTree* myKdTree)
{
FILE *fp;
fp=fopen("buhu.txt","r+");
int xAxis,yAxis;//Build Tree
int axis=0,parentAxis=1,range;
int xClosePoint,yClosePoint;//Search
float currentBest;
int menu=0,menuOption;//Menu
do{
puts("Choose one of the following:");
puts("1.Build from file");
puts("2.Display");
puts("3.Insert");
puts("4.Closest point search");
puts("5.Range Querry");
puts("6.N closest points");
puts("7.Exit");
scanf("%d",&menuOption);
char response;
switch(menuOption)
{
case 1:
{
while(feof(fp)==NULL)
{
fscanf(fp,"%d",&xAxis);
fscanf(fp,"%d",&yAxis);
myKdTree=inserare( myKdTree,xAxis,yAxis,parentAxis);
}
break;
}
case 2:
{
listare(myKdTree,0);
break;
}
case 3:
{
puts("Dati x:");
scanf("%d",&xAxis);
puts("Dati y:");
scanf("%d",&yAxis);
myKdTree=inserare( myKdTree,xAxis,yAxis,parentAxis);
break;
}
case 4:
{
currentBest=infinity;
puts("Give random number y/n?");
scanf(" %c", &response);
if(121 == response)
{
randomGeneratorPoint(xAxis,yAxis);
}
else
{
puts("Give searched point! \n");//Read Coordinates
puts("Give the x axis: \n");
scanf("%d",&xAxis);
puts("Give the y axis: \n");
puts("Dati y:");
scanf("%d",&yAxis);
}
find_closest(myKdTree,myKdTree,xAxis,yAxis,currentBest,axis,xClosePoint,yClosePoint);//Use efficient search
printf("\n Closest point using efficient methode is :",currentBest);
printf("%d ",xClosePoint);
printf("%d\n",yClosePoint);
currentBest=infinity;//Set current distance to max
hard_work(myKdTree,xAxis,yAxis,xClosePoint,yClosePoint,currentBest);
printf("\n Closest point using hardcore methode is :",currentBest);//Use shovel search
printf("%d ",xClosePoint);
printf("%d\n",yClosePoint);
break;
}
case 5:
{
puts("Give random number and range y/n?");
scanf(" %c",&response);
if(121 == response)
{
randomGeneratorPoint(xAxis,yAxis);
range=rand()%100+1;
}
else
{
puts("Give querry point! \n");//Read Coordinates and range
puts("Give the x axis: \n");
scanf("%d",&xAxis);
puts("Give the y axis: \n");
scanf("%d",&yAxis);
puts("Give range: \n");
scanf("%d",&range);
}
puts("\nThe points inside the range are: ");
range_Querry(myKdTree,myKdTree,xAxis,yAxis,range);//Use efficient search
puts("\nThe points inside the range using hard work methode are: ");
hard_Work_Querry(myKdTree,xAxis,yAxis,range);
break;
}
case 6:
{
currentBest=infinity;
int points_Number;
int contor=0;
puts("Give random number y/n?");
scanf(" %c", &response);
if(121 == response)
{
randomGeneratorPoint(xAxis,yAxis);
points_Number=rand()%14+1;
}
else
{
puts("Give searched point! \n");//Read Coordinates
puts("Give the x axis: \n");
scanf("%d",&xAxis);
puts("Give the y axis: \n");
puts("Dati y:");
scanf("%d",&yAxis);
puts("Give the number n for the closest points: \n");
scanf("%d",&points_Number);
}
std::vector<PointContainer>closest_Distances(points_Number);
find_closest_Points(myKdTree,myKdTree, xAxis, yAxis,currentBest,axis,closest_Distances,points_Number,contor);//Use efficient search
puts("\nClosest n points are: ");
for(int i=0;i<points_Number;i++)
printf(" %d %d ",closest_Distances[i].x,closest_Distances[i].y);
currentBest=infinity;//Set current distance to max
contor=0;
hard_work_closest(myKdTree,xAxis,yAxis,currentBest,closest_Distances,points_Number,contor);
puts("Closest n points using hard work are: \n");
for(int i=0;i<points_Number;i++)
printf(" %d %d ",closest_Distances[i].x,closest_Distances[i].y);
break;
puts("");
}
case 7:
{
return;
}
}
}while(menu!=7);
}
int main(int argc, char** argv){
begin = clock();
int i, j;
int b;
num_files = atoi(argv[1]);
// 4d array to have 2 layers for height and width and 2 layers for files and people
int**** pre_training_set = (int****)malloc(num_people * sizeof(int***));
for(i = 0; i < num_people; i++){
pre_training_set[i] = (int***)malloc(num_files * sizeof(int**));
}
char filename[128];
// printf("Hello\n");
for(i = 0; i < num_people; i++){
for(j = 0; j < num_files; j++){
sprintf(filename, "/home/cagdas/Desktop/parallel-project-3/images/%d.%d.txt", i+1, j+1);
// printf("%s\n", filename);
pre_training_set[i][j] = read_pgm_file(filename, rows, cols);
}
}
// printf("Creating the training set\n");
// the actual training set where the histogram arrays will be held for each file for each person (3 layers!)
int*** training_set = (int***)malloc(num_people * sizeof(int**));
for(i = 0; i < num_people; i++){
training_set[i] = (int**)malloc(num_files * sizeof(int*));
}
// create histograms for each person's each picture
for(i = 0; i < num_people; i++){
for(j = 0; j < num_files; j++){
// printf("Onto it with i %d j %d\n", i, j);
training_set[i][j] = (int*)malloc(sizeof(int) * 256);
beginp = clock();
#pragma omp parallel for schedule(static)
for(b = 0; b < 256; b++){
training_set[i][j][b] = 0;
}
endp = clock();
time_spentp += (double)(endp - beginp);
create_histogram(training_set[i][j], pre_training_set[i][j], rows, cols);
}
}
// printf("created the training set\n");
// test files
int**** pre_test_set = (int****)malloc(num_people * sizeof(int***));
for(i = 0; i < num_people; i++){
pre_test_set[i] = (int***)malloc(sizeof(int**) * (total_num_files - num_files));
}
// printf("pre test set\n");
for(i = 0; i < num_people; i++){
for(j = 0; j < (total_num_files - num_files); j++){
sprintf(filename, "/home/cagdas/Desktop/parallel-project-3/images/%d.%d.txt", i+1, j+1+num_files);
// printf("Current name is %s\n", filename);
pre_test_set[i][j] = read_pgm_file(filename, rows, cols);
}
}
// printf("created pre test set\n");
int*** test_set = (int***)malloc(num_people * sizeof(int**));
for(i = 0; i < num_people; i++){
test_set[i] = (int**)malloc((total_num_files - num_files) * sizeof(int*));
for(j = 0; j < total_num_files - num_files; j++){
test_set[i][j] = (int*)malloc(sizeof(int) * 256);
for(b = 0; b < 256; b++){
test_set[i][j][b] = 0;
}
create_histogram(test_set[i][j], pre_test_set[i][j], rows, cols);
}
}
// printf("np abi\n");
int totalCount = 0;
int falseCount = 0;
for(i = 0; i < num_people; i++){
for(j = 0; j < total_num_files - num_files; j++){
int cur = find_closest(training_set, num_people, num_files, 256, test_set[i][j]);
// test the file with file name "%d.%d.txt\t\t%d\t\t%d\n", i+1, j+1+num_files
totalCount++; // a judgment is made
if(cur != i+1){ // a false judgment is made
printf("%d.%d.txt\t\t%d\t\t%d\n", i+1, j+1+num_files, i+1, cur);
falseCount += 1;
}
}
}
printf("Accuracy: %d correct answers for %d tests Parallel\n", totalCount - falseCount, totalCount);
// TODO:: deallocate the allocated memory space
int a;
beginp = clock();
#pragma omp parallel for schedule(static) private(j,a)
for(i = 0; i < num_people; i++){
for(j = 0; j < num_files; j++){
for(a = 0; a < rows; a++){
free(pre_training_set[i][j][a]);
}
free(pre_training_set[i][j]);
}
free(pre_training_set[i]);
}
endp = clock();
time_spentp += (double)(endp - beginp);
free(pre_training_set);
// printf("free pre training set\n");
#pragma omp parallel for schedule(static) private(j,a)
for(i = 0; i < num_people; i++){
for(j = 0; j < total_num_files - num_files; j++){
for(a = 0; a < rows; a++){
free(pre_test_set[i][j][a]);
}
free(pre_test_set[i][j]);
}
free(pre_test_set[i]);
}
free(pre_test_set);
// printf("free pre test set\n");
beginp = clock();
#pragma omp parallel for schedule(static) private(j)
for(i = 0; i < num_people; i++){
for(j = 0; j < num_files; j++){
free(training_set[i][j]);
}
free(training_set[i]);
}
endp = clock();
time_spentp += (double)(endp - beginp);
free(training_set);
// printf("free training set\n");
beginp = clock();
#pragma omp parallel for schedule(static) private(j)
for(i = 0; i < num_people; i++){
for(j = 0; j < total_num_files - num_files; j++){
free(test_set[i][j]);
}
free(test_set[i]);
}
endp = clock();
time_spentp += (double)(endp - beginp);
free(test_set);
// printf("free test set\n");
end = clock();
time_spent = (double)(end-begin);
printf("Total runtime: %f\n", time_spent/CLOCKS_PER_SEC);
printf("Sequential runtime: %f\n", (time_spent - time_spentp)/CLOCKS_PER_SEC);
return 0;
}
