17#define SWAP(x, y, T) do { T SWAP = x; x = y; y = SWAP; } while (0)
21 size_t * tgt_points,
size_t count,
41 double * point,
size_t field_cell,
size_t cell_size,
42 size_t const * vertex_to_cell,
size_t const * vertex_to_cell_offsets,
46 if (cell_size == 0)
return 0;
57 cell_size *
sizeof(*coordinates_xyz))));
61 for (
size_t i = 0; i < cell_size; ++i)
68 size_t const * field_cell_vertices =
69 vertex_to_cell + vertex_to_cell_offsets[field_cell];
70 for (
size_t i = 0; i < cell_size; ++i)
71 memcpy(coordinates_xyz[i], field_coordinates[field_cell_vertices[i]],
72 sizeof(*coordinates_xyz));
77#define IS_GC(x) (((x) == YAC_GREAT_CIRCLE_EDGE) || ((x) == YAC_LON_CIRCLE_EDGE))
78#define IS_LON_LAT(x) (((x) == YAC_LAT_CIRCLE_EDGE) || ((x) == YAC_LON_CIRCLE_EDGE))
82 size_t const * edge_indices,
size_t num_edges) {
86 int edge_type_flag = 0;
91 {edge_types[edge_indices[0]],
92 edge_types[edge_indices[1]],
93 edge_types[edge_indices[2]],
94 edge_types[edge_indices[3]]};
97 (temp_edges[0] == temp_edges[2]) &&
98 (temp_edges[1] == temp_edges[3]) &&
99 (temp_edges[0] != temp_edges[1]))
103 for (
size_t i = 0; i < num_edges; ++i)
111 return cell_types[edge_type_flag];
118 size_t * tgt_points,
size_t count,
126 "ERROR(do_search_avg): invalid number of source fields")
134 "ERROR(do_search_avg): unsupported source field location type")
139 interp_grid, tgt_points, count, tgt_coords);
141 size_t * size_t_buffer =
xmalloc(2 * count *
sizeof(*size_t_buffer));
142 size_t * src_field_cells = size_t_buffer;
143 size_t * reorder_idx = size_t_buffer + count;
147 interp_grid, tgt_coords, count, src_field_cells);
149 size_t const * src_field_cell_to_vertex;
150 size_t const * src_field_cell_to_vertex_offsets;
151 size_t const * src_field_cell_to_edge;
152 size_t const * src_field_cell_to_edge_offsets;
153 int const * src_field_num_vertices_per_cell;
161 interp_grid, src_field_cells, count,
162 (
size_t**)&src_field_cell_to_vertex,
163 (
size_t**)&src_field_cell_to_vertex_offsets,
164 (
int**)&src_field_num_vertices_per_cell);
175 for (
size_t i = 0; i < count; ++i) {
177 size_t curr_src_cell = src_field_cells[i];
178 if (curr_src_cell == SIZE_MAX)
continue;
180 double * curr_tgt_coord = tgt_coords[i];
181 size_t const * curr_vertices =
184 size_t curr_num_vertices =
187 size_t result_src_field_cell = SIZE_MAX;
190 for (
size_t j = 0; j < curr_num_vertices; ++j) {
192 size_t src_field_cell = curr_vertices[j];
193 size_t src_field_cell_size =
194 (size_t)src_field_num_vertices_per_cell[src_field_cell];
198 curr_tgt_coord, src_field_cell, src_field_cell_size,
199 src_field_cell_to_vertex, src_field_cell_to_vertex_offsets,
200 src_field_coordinates, &cell_buffer)) {
201 result_src_field_cell = src_field_cell;
206 src_field_cells[i] = result_src_field_cell;
210 src_edge_types = NULL;
211 src_field_cell_to_edge = NULL;
212 src_field_cell_to_edge_offsets = NULL;
231 for (
size_t i = 0; i <
count; ++i) reorder_idx[i] = i;
234 size_t result_count = 0;
235 for (result_count = 0; result_count <
count; ++result_count)
236 if (src_field_cells[result_count] == SIZE_MAX)
break;
238 size_t total_num_weights = 0;
239 size_t max_num_vertices_per_cell = 0;
240 size_t * num_weights_per_tgt =
241 xmalloc(result_count *
sizeof(*num_weights_per_tgt));
245 for (
size_t i = 0; i < result_count; ++i) {
246 size_t curr_num_vertices =
247 (size_t)(src_field_num_vertices_per_cell[src_field_cells[i]]);
248 num_weights_per_tgt[i] = curr_num_vertices;
249 total_num_weights += curr_num_vertices;
250 if (curr_num_vertices > max_num_vertices_per_cell)
251 max_num_vertices_per_cell = curr_num_vertices;
254 free((
void*)src_field_num_vertices_per_cell);
260 xmalloc(max_num_vertices_per_cell *
sizeof(*src_coord_buffer));
262 (src_field_mask != NULL)?
263 xmalloc(max_num_vertices_per_cell *
sizeof(*mask_buffer)):NULL;
264 double * w =
xmalloc(total_num_weights *
sizeof(*w));
265 size_t * src_points =
xmalloc(total_num_weights *
sizeof(*src_points));
269 total_num_weights = 0;
270 for (
size_t i = 0; i < result_count;) {
272 size_t curr_num_vertices = num_weights_per_tgt[i];
275 src_field_cell_to_vertex +
276 src_field_cell_to_vertex_offsets[src_field_cells[i]];
278 (src_edge_types != NULL)?
279 (src_field_cell_to_edge +
280 src_field_cell_to_edge_offsets[src_field_cells[i]]):NULL;
281 double * curr_weights = w + total_num_weights;
286 size_t lowest_global_id_idx = 0;
288 yac_int lowest_global_id = src_global_ids[curr_cell_to_vertex[0]];
289 for (
size_t j = 1; j < curr_num_vertices; ++j) {
290 if (src_global_ids[curr_cell_to_vertex[j]] < lowest_global_id) {
291 lowest_global_id = src_global_ids[curr_cell_to_vertex[j]];
292 lowest_global_id_idx = j;
299 for (
size_t j = 0, l = lowest_global_id_idx; j < curr_num_vertices;
300 ++j, ++total_num_weights, ++l) {
302 if (l == curr_num_vertices) l = 0;
304 size_t curr_vertex_idx = curr_cell_to_vertex[l];
305 src_points[total_num_weights] = curr_vertex_idx;
306 for (
size_t k = 0; k < 3; ++k)
307 src_coord_buffer[j][k] = src_field_coordinates[curr_vertex_idx][k];
308 if (src_field_mask != NULL)
309 mask_buffer[j] = src_field_mask[curr_vertex_idx];
314 src_edge_types, curr_cell_to_edge, curr_num_vertices);
319 mask_buffer, curr_weights, cell_type)) {
322 num_weights_per_tgt[i] = curr_num_vertices;
327 total_num_weights -= curr_num_vertices;
329 src_field_cells[i] = src_field_cells[result_count];
330 size_t temp_reorder_idx = reorder_idx[i];
331 reorder_idx[i] = reorder_idx[result_count];
332 reorder_idx[result_count] = temp_reorder_idx;
336 free((
void*)src_field_cell_to_vertex);
337 free((
void*)src_field_cell_to_vertex_offsets);
341 for (
size_t i = 0; i <
count; ++i) src_field_cells[reorder_idx[i]] = i;
346 free(src_coord_buffer);
352 interp_grid, tgt_points, result_count),
353 .count = result_count};
356 interp_grid, 0, src_points, total_num_weights);
360 weights, &tgts, num_weights_per_tgt, srcs, w);
365 free(num_weights_per_tgt);
372 double tgt_coords[3],
size_t num_vertices,
379 size_t num_unmasked_points = 0;
382 if (src_mask != NULL) {
383 for (
size_t i = 0; i < num_vertices; ++i)
384 if (src_mask[i]) num_unmasked_points++;
385 if (num_unmasked_points == 0)
return 0;
387 double weight = 1.0 / (double)num_unmasked_points;
388 for (
size_t i = 0; i < num_vertices; ++i)
389 weights[i] = (src_mask[i])?weight:0.0;
392 double weight = 1.0 / (double)num_vertices;
393 for (
size_t i = 0; i < num_vertices; ++i) weights[i] = weight;
399 double tgt_coords[3],
size_t num_vertices,
407 if (src_mask != NULL)
408 for (
size_t i = 0; i < num_vertices; ++i)
409 if (!src_mask[i])
return 0;
411 double weight = 1.0 / (double)num_vertices;
412 for (
size_t i = 0; i < num_vertices; ++i) weights[i] = weight;
418 double tgt_coords[3],
size_t num_vertices,
425 if (src_mask != NULL) {
426 int has_unmasked = 0;
427 for (
size_t i = 0; i < num_vertices; ++i) has_unmasked |= src_mask[i];
428 if (!has_unmasked)
return 0;
431 if (src_mask != NULL) {
432 for (
size_t i = 0; i < num_vertices; ++i) {
441 for (
size_t j = 0; j < num_vertices; ++j) weights[j] = 0.0;
446 weights[i] = 1.0 / distance;
452 for (
size_t i = 0; i < num_vertices; ++i) {
459 for (
size_t j = 0; j < num_vertices; ++j) weights[j] = 0.0;
464 weights[i] = 1.0 / distance;
469 double inv_distance_sum = 0.0;
470 for (
size_t i = 0; i < num_vertices; ++i)
471 inv_distance_sum += weights[i];
472 double scale = 1.0 / inv_distance_sum;
474 for (
size_t i = 0; i < num_vertices; ++i) weights[i] *= scale;
480 double tgt_coords[3],
size_t num_vertices,
486 for (
size_t i = 0; i < num_vertices; ++i) {
493 if ((src_mask != NULL) && !src_mask[i])
return 0;
494 for (
size_t j = 0; j < num_vertices; ++j) weights[j] = 0.0;
499 weights[i] = 1.0 / distance;
505 if (src_mask != NULL)
506 for (
size_t i = 0; i < num_vertices; ++i)
if(!src_mask[i])
return 0;
509 double inv_distance_sum = 0.0;
510 for (
size_t i = 0; i < num_vertices; ++i)
511 inv_distance_sum += weights[i];
512 double scale = 1.0 / inv_distance_sum;
514 for (
size_t i = 0; i < num_vertices; ++i) weights[i] *= scale;
522 double * barycentric_coords,
size_t triangle_indices[3],
526 lapack_int n = 3, nrhs = 1, lda = n, ldx = n, ipiv[3];
527 for (
int i = 0; i < 3; ++i)
528 memcpy(A[i], grid_coords[triangle_indices[i]],
sizeof(*grid_coords));
538 LAPACK_COL_MAJOR, n, nrhs, &A[0][0], lda,
539 ipiv, barycentric_coords, ldx),
540 "ERROR: internal error (could not solve linear 3x3 system)")
546 return (a[0] * b[1] - a[1] * b[0]) < 0.0;
551 double lon[2],
double lat[2],
int reorder[4]) {
554 int lat_neigh_offset =
555 (fabs(coords[0][2] - coords[1][2]) <
556 fabs(coords[0][2] - coords[3][2]))?1:3;
559 int closest_to_equator_idx =
560 (fabs(coords[0][2]) < fabs(coords[1][2]))?0:2;
561 int upper_edge_idx = ((coords[0][2]) > coords[2][2])?0:2;
562 int lower_edge_idx = upper_edge_idx^2;
563 int upper_edge_is_closer_to_pole =
564 closest_to_equator_idx == upper_edge_idx;
565 int closest_to_equator_edge_ordering =
567 coords[closest_to_equator_idx],
568 coords[(closest_to_equator_idx+lat_neigh_offset)%4]);
570 closest_to_equator_edge_ordering ^ upper_edge_is_closer_to_pole;
573 coords[closest_to_equator_idx], &lon[closest_to_equator_edge_ordering],
574 &lat[upper_edge_is_closer_to_pole]);
576 coords[(closest_to_equator_idx + lat_neigh_offset)%4],
577 &lon[closest_to_equator_edge_ordering^1],
578 &lat[upper_edge_is_closer_to_pole]);
579 lat[!upper_edge_is_closer_to_pole] =
580 M_PI_2 - acos(coords[closest_to_equator_idx ^ 2][2]);
582 reorder[cell_ordering] = lower_edge_idx;
583 reorder[cell_ordering^1] = (lower_edge_idx+lat_neigh_offset)%4;
584 reorder[2+cell_ordering] = upper_edge_idx;
585 reorder[2+(cell_ordering^1)] = (upper_edge_idx+lat_neigh_offset)%4;
587 if (lon[1] < lon[0]) lon[1] += 2.0 * M_PI;
591 double point_coord[3],
double cell_lon[2],
double cell_lat[2],
592 double * point_lon,
double * point_lat) {
595 XYZtoLL(point_coord, &lon, &lat);
598 if (lon < cell_lon[0]) {
599 while (fabs(cell_lon[0] - lon) > M_PI) lon += 2.0 * M_PI;
601 while (fabs(lon - cell_lon[1]) > M_PI) lon -= 2.0 * M_PI;
609 double point_lon,
double point_lat,
double cell_lon[2],
double cell_lat[2]) {
611 return ((cell_lat[1] - cell_lat[0]) * (point_lat - cell_lat[0]) -
612 (cell_lat[1] - cell_lat[0]) * (point_lon - cell_lon[0])) > 0.0;
616 double tgt_coords[3],
620 double src_lon[2], src_lat[2], tgt_lon, tgt_lat;
631 w[0] = (tgt_lat - src_lat[1]) / (src_lat[0] - src_lat[1]);
632 w[1] = ((src_lat[1] - src_lat[0]) * (tgt_lon - src_lon[0])) /
633 ((src_lon[0] - src_lon[1]) * (src_lat[0] - src_lat[1]));
635 weights[src_reorder[0]] = w[0];
636 weights[src_reorder[2]] = w[1];
637 weights[src_reorder[3]] = 1.0 - (w[0] + w[1]);
638 weights[src_reorder[1]] = 0.0;
642 w[0] = (tgt_lon - src_lon[1]) / (src_lon[0] - src_lon[1]);
643 w[1] = ((src_lat[1] - src_lat[0]) * (tgt_lon - src_lon[1]) +
644 (src_lon[0] - src_lon[1]) * (tgt_lat - src_lat[1])) /
645 ((src_lat[0] - src_lat[1]) * (src_lon[0] - src_lon[1]));
647 weights[src_reorder[0]] = w[0];
648 weights[src_reorder[1]] = w[1];
649 weights[src_reorder[2]] = 1.0 - (w[0] + w[1]);
650 weights[src_reorder[3]] = 0.0;
655 double tgt_coords[3],
size_t num_vertices,
660 if (src_mask != NULL) {
662 for (i = 0; i < num_vertices; ++i)
if (src_mask[i] != 0)
break;
663 if (i == num_vertices)
return 0;
666 double const tol = 1e-9;
671 "ERROR(compute_weights_bary_yes): barycentric coordinates "
672 "are only supported for great circle edge cells and lon lat cells")
680 if (src_mask != NULL) {
681 double weight_sum = 1.0;
684 for (
int i = 0; i < 4; ++i)
if (!src_mask[i]) {
685 weight_sum -= weights[i];
690 if (weight_sum <
tol)
return 0;
693 if (weight_sum < 1.0) {
694 double scale = 1.0 / weight_sum;
695 for (
int i = 0; i < 4; ++i) weights[i] *= scale;
703 size_t corner_indices[num_vertices];
704 size_t triangle_indices[num_vertices-2][3];
706 for (
size_t i = 0; i < num_vertices; ++i) corner_indices[i] = i;
709 if (num_vertices > 3) {
711 corner_indices, num_vertices, 0, triangle_indices);
713 for (
size_t i = 0; i < 3; ++i) triangle_indices[0][i] = i;
717 double min_barycentric_coord = -DBL_MAX;
718 double barycentric_coords[3];
719 size_t match_index = SIZE_MAX;
721 for (
size_t i = 0; i < num_vertices - 2; ++i) {
723 double temp_barycentric_coords[3];
724 memcpy(temp_barycentric_coords, tgt_coords, 3 *
sizeof(
double));
728 temp_barycentric_coords, triangle_indices[i], src_coords);
730 double curr_min_barycentric_coord =
731 MIN(temp_barycentric_coords[0],
732 MIN(temp_barycentric_coords[1],
733 temp_barycentric_coords[2]));
735 if (curr_min_barycentric_coord > min_barycentric_coord) {
736 min_barycentric_coord = curr_min_barycentric_coord;
738 for (
int j = 0; j < 3; ++j)
739 barycentric_coords[j] =
MAX(0.0, temp_barycentric_coords[j]);
744 if (num_vertices > 3)
745 for (
size_t j = 0; j < num_vertices; ++j) weights[j] = 0.0;
748 if (src_mask != NULL)
749 for (
int j = 0; j < 3; ++j)
750 if (src_mask[triangle_indices[match_index][j]] == 0)
751 barycentric_coords[j] = 0.0;
753 double weight_sum = 0.0;
754 for (
int j = 0; j < 3; ++j) {
755 if (barycentric_coords[j] < 1e-4) barycentric_coords[j] = 0.0;
756 else weight_sum += barycentric_coords[j];
759 if (weight_sum <
tol)
return 0;
761 double scale = 1.0 / weight_sum;
763 for (
int j = 0; j < 3; ++j)
764 weights[triangle_indices[match_index][j]] =
765 barycentric_coords[j] * scale;
772 double tgt_coords[3],
size_t num_vertices,
777 if (src_mask != NULL) {
779 for (i = 0; i < num_vertices; ++i)
if (src_mask[i] != 0)
break;
780 if (i == num_vertices)
return 0;
783 double const tol = 1e-9;
787 "ERROR(compute_weights_bary_no): barycentric coordinates "
788 "are only supported for great circle edge cells and lon lat cells")
795 for (
int i = 0; i < 4; ++i)
if (weights[i] <
tol) weights[i] = 0.0;
798 if (src_mask != NULL)
799 for (
int i = 0; i < 4; ++i)
800 if (!src_mask[i] && (weights[i] != 0.0))
806 size_t corner_indices[num_vertices];
807 size_t triangle_indices[num_vertices-2][3];
809 for (
size_t i = 0; i < num_vertices; ++i) corner_indices[i] = i;
812 if (num_vertices > 3) {
814 corner_indices, num_vertices, 0, triangle_indices);
816 for (
size_t i = 0; i < 3; ++i) triangle_indices[0][i] = i;
820 double min_barycentric_coord = -DBL_MAX;
821 double barycentric_coords[3];
822 size_t match_index = SIZE_MAX;
824 for (
size_t i = 0; i < num_vertices - 2; ++i) {
826 double temp_barycentric_coords[3];
827 memcpy(temp_barycentric_coords, tgt_coords, 3 *
sizeof(
double));
831 temp_barycentric_coords, triangle_indices[i], src_coords);
833 double curr_min_barycentric_coord =
834 MIN(temp_barycentric_coords[0],
835 MIN(temp_barycentric_coords[1],
836 temp_barycentric_coords[2]));
838 if (curr_min_barycentric_coord > min_barycentric_coord) {
839 min_barycentric_coord = curr_min_barycentric_coord;
841 for (
int j = 0; j < 3; ++j)
842 barycentric_coords[j] =
MAX(0.0, temp_barycentric_coords[j]);
847 if (num_vertices > 3)
848 for (
size_t j = 0; j < num_vertices; ++j) weights[j] = 0.0;
851 if (src_mask != NULL)
852 for (
int j = 0; j < 3; ++j)
853 if (!src_mask[triangle_indices[match_index][j]] &&
854 (barycentric_coords[j] >= 1e-4))
return 0;
856 double weight_sum = 0.0;
857 for (
int j = 0; j < 3; ++j) {
858 if (barycentric_coords[j] < 1e-4) barycentric_coords[j] = 0.0;
859 else weight_sum += barycentric_coords[j];
862 if (weight_sum <
tol)
return 0;
864 double scale = 1.0 / weight_sum;
866 for (
int j = 0; j < 3; ++j)
867 weights[triangle_indices[match_index][j]] =
868 barycentric_coords[j] * scale;
881 "ERROR(select_compute_weight_routine): invalid weight type")
883 switch(weight_type) {
896 int partial_coverage) {
int yac_point_in_cell(double point_coords[3], struct yac_grid_cell cell)
size_t const *const const_size_t_pointer
int const *const const_int_pointer
yac_int const *const const_yac_int_pointer
void yac_triangulate_cell_indices(size_t const *corner_indices, size_t num_corners, size_t start_corner, size_t(*triangle_indices)[3])
static double get_vector_angle(double const a[3], double const b[3])
static void XYZtoLL(double const p_in[], double *lon, double *lat)
void yac_init_grid_cell(struct yac_grid_cell *cell)
void yac_free_grid_cell(struct yac_grid_cell *cell)
@ YAC_GREAT_CIRCLE_EDGE
great circle
@ YAC_LAT_CIRCLE_EDGE
latitude circle
void yac_interp_grid_do_points_search(struct yac_interp_grid *interp_grid, yac_coordinate_pointer search_coords, size_t count, size_t *src_cells)
size_t yac_interp_grid_get_num_src_fields(struct yac_interp_grid *interp_grid)
const_int_pointer yac_interp_grid_get_src_field_mask(struct yac_interp_grid *interp_grid, size_t src_field_idx)
void yac_interp_grid_get_aux_grid_src(struct yac_interp_grid *interp_grid, size_t *cells, size_t count, size_t **vertex_to_cell, size_t **vertex_to_cell_offsets, int **num_cells_per_vertex)
const_yac_int_pointer yac_interp_grid_get_src_field_global_ids(struct yac_interp_grid *interp_grid, size_t src_field_idx)
struct remote_point * yac_interp_grid_get_tgt_remote_points(struct yac_interp_grid *interp_grid, size_t *tgt_points, size_t count)
enum yac_location yac_interp_grid_get_src_field_location(struct yac_interp_grid *interp_grid, size_t src_field_idx)
struct remote_point * yac_interp_grid_get_src_remote_points(struct yac_interp_grid *interp_grid, size_t src_field_idx, size_t *src_points, size_t count)
yac_const_coordinate_pointer yac_interp_grid_get_src_field_coords(struct yac_interp_grid *interp_grid, size_t src_field_idx)
void yac_interp_grid_get_tgt_coordinates(struct yac_interp_grid *interp_grid, size_t *tgt_points, size_t count, yac_coordinate_pointer tgt_coordinates)
struct yac_const_basic_grid_data * yac_interp_grid_get_basic_grid_data_src(struct yac_interp_grid *interp_grid)
static int compute_weights_avg_no(double tgt_coords[3], size_t num_vertices, yac_const_coordinate_pointer src_coords, int *src_mask, double *weights, enum yac_cell_type cell_type)
static int compute_weights_avg_yes(double tgt_coords[3], size_t num_vertices, yac_const_coordinate_pointer src_coords, int *src_mask, double *weights, enum yac_cell_type cell_type)
static size_t do_search_avg(struct interp_method *method, struct yac_interp_grid *interp_grid, size_t *tgt_points, size_t count, struct yac_interp_weights *weights)
static int check_src_field_cell(double *point, size_t field_cell, size_t cell_size, size_t const *vertex_to_cell, size_t const *vertex_to_cell_offsets, yac_const_coordinate_pointer field_coordinates, struct yac_grid_cell *cell_buffer)
static struct interp_method_vtable interp_method_avg_vtable
static void get_point_lon_lat(double point_coord[3], double cell_lon[2], double cell_lat[2], double *point_lon, double *point_lat)
int(* func_compute_weights)(double[3], size_t, yac_const_coordinate_pointer, int *, double *, enum yac_cell_type cell_type)
struct interp_method * yac_interp_method_avg_new(enum yac_interp_avg_weight_type weight_type, int partial_coverage)
static func_compute_weights select_compute_weight_routine(enum yac_interp_avg_weight_type weight_type, int partial_coverage)
static void compute_barycentric_coords(double *barycentric_coords, size_t triangle_indices[3], yac_const_coordinate_pointer grid_coords)
static int compute_weights_dist_no(double tgt_coords[3], size_t num_vertices, yac_const_coordinate_pointer src_coords, int *src_mask, double *weights, enum yac_cell_type cell_type)
static int compute_weights_bary_no(double tgt_coords[3], size_t num_vertices, yac_const_coordinate_pointer src_coords, int *src_mask, double *weights, enum yac_cell_type cell_type)
static int determine_triangle_idx(double point_lon, double point_lat, double cell_lon[2], double cell_lat[2])
static int compute_weights_dist_yes(double tgt_coords[3], size_t num_vertices, yac_const_coordinate_pointer src_coords, int *src_mask, double *weights, enum yac_cell_type cell_type)
static void delete_avg(struct interp_method *method)
static int get_lat_edge_ordering(double const *a, double const *b)
static void get_cell_lon_lat_bounds(yac_const_coordinate_pointer coords, double lon[2], double lat[2], int reorder[4])
static enum yac_cell_type determine_cell_type(enum yac_edge_type const *edge_types, size_t const *edge_indices, size_t num_edges)
static int compute_weights_bary_yes(double tgt_coords[3], size_t num_vertices, yac_const_coordinate_pointer src_coords, int *src_mask, double *weights, enum yac_cell_type cell_type)
static void compute_weights_bary_reg(double tgt_coords[3], yac_const_coordinate_pointer src_coords, double *weights)
yac_interp_avg_weight_type
@ YAC_INTERP_AVG_ARITHMETIC
static void compute_weights(struct tgt_point_search_data *tgt_point_data, size_t num_tgt_points, struct edge_interp_data *edge_data, size_t num_edges, struct triangle_interp_data *triangle_data, size_t num_triangles, struct weight_vector_data **weights, size_t **num_weights_per_tgt, size_t *total_num_weights)
void yac_interp_weights_add_wsum(struct yac_interp_weights *weights, struct remote_points *tgts, size_t *num_src_per_tgt, struct remote_point *srcs, double *w)
#define xrealloc(ptr, size)
struct interp_method_vtable * vtable
func_compute_weights compute_weights
size_t(* do_search)(struct interp_method *method, struct yac_interp_grid *grid, size_t *tgt_points, size_t count, struct yac_interp_weights *weights)
struct remote_point * data
const_int_pointer num_vertices_per_cell
const_size_t_pointer cell_to_vertex_offsets
const_size_t_pointer cell_to_vertex
const_size_t_pointer cell_to_edge
const_size_t_pointer cell_to_edge_offsets
const_yac_edge_type_pointer edge_type
enum yac_edge_type * edge_type
double(* coordinates_xyz)[3]
void yac_quicksort_index_size_t_size_t(size_t *a, size_t n, size_t *idx)
#define YAC_ASSERT(exp, msg)
double const (*const yac_const_coordinate_pointer)[3]
double(* yac_coordinate_pointer)[3]