Go to the documentation of this file.
47 double alpha_slow,
double alpha_fast,
57 pf = calloc(1,
sizeof(
pf_t));
78 for (j = 0; j < 2; j++)
82 set->sample_count = max_samples;
85 for (i = 0; i <
set->sample_count; i++)
87 sample =
set->samples + i;
88 sample->
pose.
v[0] = 0.0;
89 sample->
pose.
v[1] = 0.0;
90 sample->
pose.
v[2] = 0.0;
91 sample->
weight = 1.0 / max_samples;
97 set->cluster_count = 0;
98 set->cluster_max_count = max_samples;
124 for (i = 0; i < 2; i++)
153 for (i = 0; i <
set->sample_count; i++)
155 sample =
set->samples + i;
192 for (i = 0; i <
set->sample_count; i++)
194 sample =
set->samples + i;
196 sample->
pose = (*init_fn) (init_data);
228 double mean_x = 0, mean_y = 0;
230 for (i = 0; i <
set->sample_count; i++){
231 sample =
set->samples + i;
233 mean_x += sample->
pose.
v[0];
234 mean_y += sample->
pose.
v[1];
236 mean_x /=
set->sample_count;
237 mean_y /=
set->sample_count;
239 for (i = 0; i <
set->sample_count; i++){
240 sample =
set->samples + i;
260 (*action_fn) (action_data,
set);
278 total = (*sensor_fn) (sensor_data,
set);
280 set->n_effective = 0;
286 for (i = 0; i <
set->sample_count; i++)
288 sample =
set->samples + i;
294 w_avg /=
set->sample_count;
309 for (i = 0; i <
set->sample_count; i++)
311 sample =
set->samples + i;
312 sample->
weight = 1.0 /
set->sample_count;
316 set->n_effective = 1.0/
set->n_effective;
340 assert(sample_a->
weight > 0);
346 total += sample_b->
weight;
356 sample_b->
weight /= total;
399 c = (
double*)malloc(
sizeof(
double)*(set_a->
sample_count+1));
463 if((c[i] <= r) && (r < c[i+1]))
466 assert(i<set_a->sample_count);
470 assert(sample_a->
weight > 0);
477 total += sample_b->
weight;
497 sample_b->
weight /= total;
536 b = 2 / (9 * ((double) k - 1));
537 c = sqrt(2 / (9 * ((
double) k - 1))) * pf->
pop_z;
540 n = (int) ceil((k - 1) / (2 * pf->
pop_err) * x * x * x);
542 if (n < pf->min_samples)
566 double m[4], c[2][2];
574 set->cluster_count = 0;
576 for (i = 0; i <
set->cluster_max_count; i++)
578 cluster =
set->clusters + i;
584 for (j = 0; j < 4; j++)
586 for (j = 0; j < 2; j++)
587 for (k = 0; k < 2; k++)
588 cluster->
c[j][k] = 0.0;
596 for (j = 0; j < 4; j++)
598 for (j = 0; j < 2; j++)
599 for (k = 0; k < 2; k++)
603 for (i = 0; i <
set->sample_count; i++)
605 sample =
set->samples + i;
612 if (cidx >=
set->cluster_max_count)
614 if (cidx + 1 >
set->cluster_count)
615 set->cluster_count = cidx + 1;
617 cluster =
set->clusters + cidx;
628 cluster->
m[2] += sample->
weight * cos(sample->
pose.
v[2]);
629 cluster->
m[3] += sample->
weight * sin(sample->
pose.
v[2]);
637 for (j = 0; j < 2; j++)
638 for (k = 0; k < 2; k++)
646 for (i = 0; i <
set->cluster_count; i++)
648 cluster =
set->clusters + i;
652 cluster->
mean.
v[2] = atan2(cluster->
m[3], cluster->
m[2]);
657 for (j = 0; j < 2; j++)
658 for (k = 0; k < 2; k++)
659 cluster->
cov.
m[j][k] = cluster->
c[j][k] / cluster->
weight -
664 cluster->
cov.
m[2][2] = -2 * log(sqrt(cluster->
m[2] * cluster->
m[2] +
665 cluster->
m[3] * cluster->
m[3]) / cluster->
weight);
672 assert(fabs(weight) >= DBL_EPSILON);
673 if (fabs(weight) < DBL_EPSILON)
675 printf(
"ERROR : divide-by-zero exception : weight is zero\n");
679 set->mean.v[0] = m[0] / weight;
680 set->mean.v[1] = m[1] / weight;
681 set->mean.v[2] = atan2(m[3], m[2]);
684 for (j = 0; j < 2; j++)
685 for (k = 0; k < 2; k++)
686 set->cov.m[j][k] = c[j][k] / weight -
set->mean.v[j] *
set->mean.v[k];
690 set->cov.m[2][2] = -2 * log(sqrt(m[2] * m[2] + m[3] * m[3]));
704 double mn, mx, my, mrr;
715 for (i = 0; i <
set->sample_count; i++)
717 sample =
set->samples + i;
726 assert(fabs(mn) >= DBL_EPSILON);
727 if (fabs(mn) < DBL_EPSILON)
729 printf(
"ERROR : divide-by-zero exception : mn is zero\n");
733 mean->
v[0] = mx / mn;
734 mean->
v[1] = my / mn;
737 *var = mrr / mn - (mx * mx / (mn * mn) + my * my / (mn * mn));
752 if (clabel >=
set->cluster_count)
754 cluster =
set->clusters + clabel;
756 *weight = cluster->
weight;
757 *mean = cluster->
mean;
pf_matrix_t pf_matrix_zero()
void pf_kdtree_cluster(pf_kdtree_t *self)
int pf_get_cluster_stats(pf_t *pf, int clabel, double *weight, pf_vector_t *mean, pf_matrix_t *cov)
void pf_update_action(pf_t *pf, pf_action_model_fn_t action_fn, void *action_data)
int pf_kdtree_get_cluster(pf_kdtree_t *self, pf_vector_t pose)
pf_t * pf_alloc(int min_samples, int max_samples, double alpha_slow, double alpha_fast, pf_init_model_fn_t random_pose_fn, void *random_pose_data)
static double drand48(void)
void pf_update_resample(pf_t *pf)
pf_kdtree_t * pf_kdtree_alloc(int max_size)
static void srand48(long int seedval)
void pf_set_selective_resampling(pf_t *pf, int selective_resampling)
double(* pf_sensor_model_fn_t)(void *sensor_data, struct _pf_sample_set_t *set)
pf_vector_t(* pf_init_model_fn_t)(void *init_data)
void pf_cluster_stats(pf_t *pf, pf_sample_set_t *set)
void pf_pdf_gaussian_free(pf_pdf_gaussian_t *pdf)
pf_vector_t pf_vector_zero()
void pf_init_model(pf_t *pf, pf_init_model_fn_t init_fn, void *init_data)
void pf_kdtree_clear(pf_kdtree_t *self)
ROSCPP_DECL void set(const std::string &key, bool b)
pf_pdf_gaussian_t * pf_pdf_gaussian_alloc(pf_vector_t x, pf_matrix_t cx)
void pf_init(pf_t *pf, pf_vector_t mean, pf_matrix_t cov)
void pf_kdtree_insert(pf_kdtree_t *self, pf_vector_t pose, double value)
static int pf_resample_limit(pf_t *pf, int k)
void pf_update_sensor(pf_t *pf, pf_sensor_model_fn_t sensor_fn, void *sensor_data)
void copy_set(pf_sample_set_t *set_a, pf_sample_set_t *set_b)
pf_init_model_fn_t random_pose_fn
void pf_get_cep_stats(pf_t *pf, pf_vector_t *mean, double *var)
void pf_init_converged(pf_t *pf)
void(* pf_action_model_fn_t)(void *action_data, struct _pf_sample_set_t *set)
void pf_kdtree_free(pf_kdtree_t *self)
pf_vector_t pf_pdf_gaussian_sample(pf_pdf_gaussian_t *pdf)
int pf_update_converged(pf_t *pf)
amcl
Author(s): Brian P. Gerkey, contradict@gmail.com
autogenerated on Mon Mar 6 2023 03:50:13