58 const std::optional<bke::bvh::ClosestPointResult> nearest = tree.
closest_point(co, max_dist);
62 *r_index = int(nearest->index);
70 const float max_dist_sq,
74 if (nearest->
index != -1) {
76 if (nearest->
dist_sq > max_dist_sq) {
88 if ((nearest->
index != -1) && (nearest->
dist_sq <= max_dist_sq)) {
101 const float max_dist,
108 rayhit->
dist = max_dist;
113 rayhit_tmp = *rayhit;
117 if (rayhit_tmp.
dist < rayhit->
dist) {
118 *rayhit = rayhit_tmp;
121 if ((rayhit->
index != -1) && (rayhit->
dist <= max_dist)) {
122 *r_hit_dist = rayhit->
dist;
148 for (i = 0; i < vert_positions_dst.
size(); i++) {
149 float3 tmp_co = vert_positions_dst[i];
152 if (space_transform) {
158 result += 1.0f / (hit_dist + 1.0f);
169 printf(
"%s: Computed difference between meshes (the lower the better): %f\n", __func__,
result);
189 float center[3], covmat[3][3];
190 float eigen_val[3], eigen_vec[3][3];
200 int(positions.
size()),
206 const_cast<const float (*)[3]
>(covmat), eigen_val, eigen_vec);
234 for (i = 0; i < 3; i++) {
235 float evi = eigen_val[i];
242 evi = (evi < 1e-6f && evi > -1e-6f) ? ((evi < 0.0f) ? -1e-3f : 1e-3f) :
sqrtf_signed(evi);
256 const float mirrors[][3] = {
266 const float (*mirr)[3];
268 float mat_src[4][4], mat_dst[4][4], best_mat_dst[4][4];
269 float best_match =
FLT_MAX, match;
271 const Span<float3> positions_src = me_src->vert_positions();
281 for (mirr = mirrors; (*mirr)[0]; mirr++) {
288 r_space_transform, vert_positions_dst, me_src);
289 if (match < best_match) {
324 map->
items =
nullptr;
332 const int sources_num,
333 const int *indices_src,
334 const float *weights_src)
365 const float point[3],
368 const bool use_loops,
371 const bool do_weights,
372 int *r_closest_index)
377 const int sources_num = int(face.
size());
380 if (
size_t(sources_num) > *buff_size) {
381 *buff_size = size_t(sources_num);
382 *vcos =
static_cast<float (*)[3]
>(
384 *indices =
static_cast<int *
>(
387 *weights =
static_cast<float *
>(
392 for (i = 0, vco = *vcos,
index = *indices; i < sources_num; i++, vco++,
index++) {
393 const int vert = corner_verts[face[i]];
394 *
index = use_loops ? int(face[i]) : vert;
396 if (r_closest_index) {
399 if (dist_sq < ref_dist_sq) {
400 ref_dist_sq = dist_sq;
401 *r_closest_index = *
index;
442#define MREMAP_RAYCAST_APPROXIMATE_NR 3
444#define MREMAP_RAYCAST_APPROXIMATE_FAC 5.0f
447#define MREMAP_RAYCAST_TRI_SAMPLES_MIN 4
448#define MREMAP_RAYCAST_TRI_SAMPLES_MAX 20
451#define MREMAP_DEFAULT_BUFSIZE 32
455 const float max_dist,
456 const float ray_radius,
462 const float full_weight = 1.0f;
463 const float max_dist_sq = max_dist * max_dist;
472 for (i = 0; i < vert_positions_dst.
size(); i++) {
481 float tmp_co[3], tmp_no[3];
486 for (i = 0; i < vert_positions_dst.
size(); i++) {
487 float3 co = vert_positions_dst[i];
490 if (space_transform) {
506 const Span<float3> positions_src = me_src->vert_positions();
510 for (i = 0; i < vert_positions_dst.
size(); i++) {
511 float3 co = vert_positions_dst[i];
514 if (space_transform) {
520 const int2 &edge = edges_src[edge_index];
521 const float *v1cos = positions_src[edge[0]];
522 const float *v2cos = positions_src[edge[1]];
527 const int index = (dist_v1 > dist_v2) ? edge[1] : edge[0];
534 indices[0] = edge[0];
535 indices[1] = edge[1];
539 CLAMP(weights[0], 0.0f, 1.0f);
540 weights[1] = 1.0f - weights[0];
557 const Span<int> corner_verts_src = me_src->corner_verts();
558 const Span<float3> positions_src = me_src->vert_positions();
559 const Span<float3> vert_normals_dst = me_dst->vert_normals();
560 const Span<int> tri_faces = me_src->corner_tri_faces();
567 treedata = me_src->bvh_corner_tris();
570 for (i = 0; i < vert_positions_dst.
size(); i++) {
575 if (space_transform) {
581 &treedata, &rayhit, tmp_co, tmp_no, ray_radius, max_dist, &hit_dist))
583 const int face_index = tri_faces[rayhit.
index];
607 for (i = 0; i < vert_positions_dst.
size(); i++) {
611 if (space_transform) {
616 &treedata, &nearest, tmp_co, max_dist_sq, &hit_dist))
618 const int face_index = tri_faces[nearest.
index];
664 CLOG_WARN(&
LOG,
"Unsupported mesh-to-mesh vertex mapping mode (%d)!", mode);
665 memset(r_map->
items, 0,
sizeof(*r_map->
items) *
size_t(vert_positions_dst.
size()));
672 const float max_dist,
673 const float ray_radius,
680 const float full_weight = 1.0f;
681 const float max_dist_sq = max_dist * max_dist;
690 for (i = 0; i < edges_dst.
size(); i++) {
699 float tmp_co[3], tmp_no[3];
702 const int num_verts_src = me_src->
verts_num;
704 const Span<float3> positions_src = me_src->vert_positions();
711 size_t(vert_positions_dst.
size()), __func__);
713 for (i = 0; i < vert_positions_dst.
size(); i++) {
714 v_dst_to_src_map[i].hit_dist = -1.0f;
720 edges_src, num_verts_src, vert_to_edge_src_offsets, vert_to_edge_src_indices);
724 for (i = 0; i < edges_dst.
size(); i++) {
725 const int2 &e_dst = edges_dst[i];
727 int best_eidx_src = -1;
731 const int vidx_dst = j ? e_dst[0] : e_dst[1];
734 if (v_dst_to_src_map[vidx_dst].hit_dist == -1.0f) {
735 float3 co = vert_positions_dst[vidx_dst];
738 if (space_transform) {
744 v_dst_to_src_map[vidx_dst].hit_dist = hit_dist;
745 v_dst_to_src_map[vidx_dst].index =
index;
749 v_dst_to_src_map[vidx_dst].hit_dist =
FLT_MAX;
757 const int vidx_dst = j ? e_dst[0] : e_dst[1];
758 const float first_dist = v_dst_to_src_map[vidx_dst].hit_dist;
759 const int vidx_src = v_dst_to_src_map[vidx_dst].index;
767 eidx_src = vert_to_edge_src_map[vidx_src].
data();
768 k = int(vert_to_edge_src_map[vidx_src].size());
770 for (; k--; eidx_src++) {
771 const int2 &edge_src = edges_src[*eidx_src];
772 const float *other_co_src =
774 const float *other_co_dst =
776 const float totdist = first_dist +
len_v3v3(other_co_src, other_co_dst);
778 if (totdist < best_totdist) {
779 best_totdist = totdist;
780 best_eidx_src = *eidx_src;
785 if (best_eidx_src >= 0) {
786 const float *co1_src = positions_src[edges_src[best_eidx_src][0]];
787 const float *co2_src = positions_src[edges_src[best_eidx_src][1]];
788 const float *co1_dst = vert_positions_dst[e_dst[0]];
789 const float *co2_dst = vert_positions_dst[e_dst[1]];
790 float co_src[3], co_dst[3];
794 co1_src, co2_src, co1_dst, co2_dst, co_src, co_dst);
795 if (isect_type != 0) {
798 if (fac_src < 0.0f) {
801 else if (fac_src > 1.0f) {
804 if (fac_dst < 0.0f) {
807 else if (fac_dst > 1.0f) {
811 hit_dist =
len_v3v3(co_dst, co_src);
820 MEM_delete(v_dst_to_src_map);
825 for (i = 0; i < edges_dst.
size(); i++) {
827 vert_positions_dst[edges_dst[i][1]]);
830 if (space_transform) {
847 const Span<int> corner_edges_src = me_src->corner_edges();
848 const Span<float3> positions_src = me_src->vert_positions();
849 const Span<int> tri_faces = me_src->corner_tri_faces();
851 treedata = me_src->bvh_corner_tris();
853 for (i = 0; i < edges_dst.
size(); i++) {
855 vert_positions_dst[edges_dst[i][0]],
856 vert_positions_dst[edges_dst[i][1]],
860 if (space_transform) {
866 const int face_index = tri_faces[nearest.
index];
867 const IndexRange face_src = faces_src[face_index];
868 const int *corner_edge_src = &corner_edges_src[face_src.
start()];
869 int nloops = int(face_src.
size());
871 int best_eidx_src = -1;
873 for (; nloops--; corner_edge_src++) {
874 const int2 &edge_src = edges_src[*corner_edge_src];
875 const float *co1_src = positions_src[edge_src[0]];
876 const float *co2_src = positions_src[edge_src[1]];
882 if (dist_sq < best_dist_sq) {
883 best_dist_sq = dist_sq;
884 best_eidx_src = *corner_edge_src;
887 if (best_eidx_src >= 0) {
898 const int num_rays_min = 5, num_rays_max = 100;
899 const int numedges_src = me_src->
edges_num;
908 treedata = me_src->bvh_edges_legacy();
910 const Span<float3> vert_normals_dst = me_dst->vert_normals();
912 for (i = 0; i < edges_dst.
size(); i++) {
915 const int2 &edge = edges_dst[i];
916 float v1_co[3], v2_co[3];
917 float v1_no[3], v2_no[3];
923 float totweights = 0.0f;
924 float hit_dist_accum = 0.0f;
928 copy_v3_v3(v1_co, vert_positions_dst[edge[0]]);
929 copy_v3_v3(v2_co, vert_positions_dst[edge[1]]);
935 if (space_transform) {
942 std::fill_n(weights,
int(numedges_src), 0.0f);
946 edge_dst_len =
len_v3v3(v1_co, v2_co);
948 grid_size = int((edge_dst_len / ray_radius) + 0.5f);
949 CLAMP(grid_size, num_rays_min, num_rays_max);
952 grid_step = 1.0f /
float(grid_size);
955 for (j = 0; j < grid_size; j++) {
956 const float fac = grid_step *
float(j);
966 &treedata, &rayhit, tmp_co, tmp_no, ray_radius /
w, max_dist, &hit_dist))
968 weights[rayhit.
index] +=
w;
970 hit_dist_accum += hit_dist;
979 if (totweights > (
float(grid_size) / 2.0f)) {
980 for (j = 0; j < int(numedges_src); j++) {
985 weights[sources_num] = weights[j] / totweights;
986 indices[sources_num] = j;
990 r_map, i, hit_dist_accum / totweights, 0, sources_num, indices, weights);
1002 CLOG_WARN(&
LOG,
"Unsupported mesh-to-mesh edge mapping mode (%d)!", mode);
1003 memset(r_map->
items, 0,
sizeof(*r_map->
items) *
size_t(edges_dst.
size()));
1009#define POLY_CENTER_INIT 1
1010#define POLY_COMPLETE 2
1013 const int island_index,
1021 const bool is_edge_innercut,
1022 const int *face_island_index_map,
1023 float (*face_centers)[3],
1026 Array<int, 16> face_island_indices(edge_to_face_map[edge_idx].size());
1029 for (i = 0; i < edge_to_face_map[edge_idx].
size(); i++) {
1030 const int pidx = edge_to_face_map[edge_idx][i];
1032 const int pidx_isld =
islands ? face_island_index_map[pidx] : pidx;
1037 face_island_indices[i] = -1;
1042 face_island_indices[i] = pidx_isld;
1055 const int pidx_isld_other = face_island_indices[j];
1057 if (pidx_isld_other == -1 || face_status[pidx_isld_other] ==
POLY_COMPLETE) {
1061 dist_cost =
len_v3v3(face_centers[pidx_isld_other], face_centers[pidx_isld]);
1065 face_island_indices[i] = pidx_isld;
1072 const int island_index,
1084 int *face_island_index_map =
nullptr;
1089 float (*face_centers)[3];
1096 face_centers =
static_cast<float (*)[3]
>(
1102 r_as_graph->
mem,
sizeof(*face_island_index_map) *
size_t(faces.
size())));
1103 for (i = island_face_map->
count; i--;) {
1104 face_island_index_map[island_face_map->
indices[i]] = i;
1109 for (i = island_einnercut_map->
count; i--;) {
1116 island_einnercut_map->
indices[i],
1120 face_island_index_map,
1126 for (pidx_isld = node_num; pidx_isld--;) {
1127 const int pidx =
islands ? island_face_map->
indices[pidx_isld] : pidx_isld;
1133 for (
const int edge : corner_edges.
slice(faces[pidx])) {
1148 face_island_index_map,
1155 MEM_delete(done_edges);
1156 MEM_delete(face_status);
1160#undef POLY_CENTER_INIT
1169 const int node_idx_curr,
1170 const int node_idx_next,
1171 const int node_idx_dst)
1173 float *co_next, *co_dest;
1187 co_next =
static_cast<float *
>(as_graph->
nodes[node_idx_next].
custom_data);
1189 return (link ? (as_solution->
g_costs[node_idx_curr] + link->
cost) : 0.0f) +
1193#define ASTAR_STEPS_MAX 64
1197 const float max_dist,
1198 const float ray_radius,
1199 const Mesh *mesh_dst,
1205 const float islands_precision_src,
1208 const float full_weight = 1.0f;
1209 const float max_dist_sq = max_dist * max_dist;
1212 BLI_assert((islands_precision_src >= 0.0f) && (islands_precision_src <= 1.0f));
1219 for (
int i = 0; i < corner_verts_dst.
size(); i++) {
1232 float tmp_co[3], tmp_no[3];
1237 bool use_islands =
false;
1241 const int isld_steps_src = (islands_precision_src ?
1261 MeshElemMap *face_to_corner_tri_map_src =
nullptr;
1262 int *face_to_corner_tri_map_src_buff =
nullptr;
1267 const Span<float3> positions_src = me_src->vert_positions();
1268 const int num_verts_src = me_src->
verts_num;
1269 const Span<int2> edges_src = me_src->edges();
1271 const Span<int> corner_verts_src = me_src->corner_verts();
1272 const Span<int> corner_edges_src = me_src->corner_edges();
1277 float (*vcos_interp)[3] =
nullptr;
1278 int *indices_interp =
nullptr;
1279 float *weights_interp =
nullptr;
1281 int tindex, pidx_dst, lidx_dst, plidx_dst, pidx_src, lidx_src, plidx_src;
1286 if (!use_from_vert) {
1295 const bool need_pnors_src = need_lnors_src ||
1297 const bool need_pnors_dst = need_lnors_dst || need_pnors_src;
1299 if (need_pnors_dst) {
1300 face_normals_dst = mesh_dst->face_normals();
1302 if (need_lnors_dst) {
1303 loop_normals_dst = mesh_dst->corner_normals();
1305 if (need_pnors_src) {
1306 face_normals_src = me_src->face_normals();
1308 if (need_lnors_src) {
1309 loop_normals_src = me_src->corner_normals();
1313 if (use_from_vert) {
1314 vert_to_corner_map_src = me_src->vert_to_corner_map();
1316 vert_to_face_map_src = me_src->vert_to_face_map();
1323 int(edges_src.
size()),
1324 edge_to_face_src_offsets,
1325 edge_to_face_src_indices);
1327 if (use_from_vert) {
1328 loop_to_face_map_src = me_src->corner_to_face_map();
1332 corner_verts_src.
slice(faces_src[i]));
1344 if (gen_islands_src) {
1347 use_islands = gen_islands_src(positions_src,
1355 num_trees = use_islands ? island_store.
islands_num : 1;
1357 if (isld_steps_src) {
1373 if (isld_steps_src) {
1379 if (isld_steps_src) {
1380 for (tindex = 0; tindex < num_trees; tindex++) {
1384 edge_to_face_map_src,
1385 int(edges_src.
size()),
1389 &as_graphdata[tindex]);
1394 if (use_from_vert) {
1400 for (tindex = 0; tindex < num_trees; tindex++) {
1402 verts_active.
fill(
false);
1403 for (
int i = 0; i < isld->
count; i++) {
1404 for (
const int vidx_src : corner_verts_src.
slice(faces_src[isld->
indices[i]])) {
1405 if (!verts_active[vidx_src]) {
1406 verts_active[vidx_src].set();
1413 vert_trees[tindex] = &island_vert_trees[tindex];
1418 vert_trees[0] = &me_src->bvh_verts();
1423 corner_tris_src = me_src->corner_tris();
1424 tri_faces_src = me_src->corner_tri_faces();
1427 for (tindex = 0; tindex < num_trees; tindex++) {
1428 faces_active.
fill(
false);
1432 faces_active[i].set();
1446 treedata[0] = me_src->bvh_corner_tris();
1452 for (tindex = 0; tindex < num_trees; tindex++) {
1456 const Span<int> tri_faces = me_src->corner_tri_faces();
1458 for (pidx_dst = 0; pidx_dst < faces_dst.
size(); pidx_dst++) {
1459 const IndexRange face_dst = faces_dst[pidx_dst];
1465 bool pcent_dst_valid =
false;
1468 copy_v3_v3(pnor_dst, face_normals_dst[pidx_dst]);
1469 if (space_transform) {
1474 if (
size_t(face_dst.
size()) > islands_res_buff_size) {
1476 for (tindex = 0; tindex < num_trees; tindex++) {
1478 islands_res[tindex],
sizeof(**islands_res) * islands_res_buff_size));
1482 for (tindex = 0; tindex < num_trees; tindex++) {
1485 for (plidx_dst = 0; plidx_dst < face_dst.
size(); plidx_dst++) {
1486 const int vert_dst = corner_verts_dst[face_dst.
start() + plidx_dst];
1487 if (use_from_vert) {
1490 float3 co = vert_positions_dst[vert_dst];
1493 if (space_transform) {
1497 int nearest_vert_src;
1499 *vert_trees[tindex], co, max_dist, &nearest_vert_src, &hit_dist))
1501 float (*nor_dst)[3];
1503 float best_nor_dot = -2.0f;
1504 float best_sqdist_fallback =
FLT_MAX;
1505 int best_index_src = -1;
1509 if (space_transform) {
1513 nors_src = loop_normals_src;
1514 vert_to_refelem_map_src = vert_to_corner_map_src[nearest_vert_src];
1517 nor_dst = &pnor_dst;
1518 nors_src = face_normals_src;
1519 vert_to_refelem_map_src = vert_to_face_map_src[nearest_vert_src];
1522 for (
const int index_src : vert_to_refelem_map_src) {
1524 const float dot =
dot_v3v3(nors_src[index_src], *nor_dst);
1527 loop_to_face_map_src[index_src] :
1534 int(faces_src[pidx_src].start()));
1542 if (
dot > best_nor_dot - 1e-6f) {
1548 if (!pcent_dst_valid) {
1550 corner_verts_dst.
slice(face_dst));
1551 pcent_dst_valid =
true;
1553 pcent_src = face_cents_src[pidx_src];
1556 if ((
dot > best_nor_dot + 1e-6f) || (sqdist < best_sqdist_fallback)) {
1558 best_sqdist_fallback = sqdist;
1559 best_index_src = index_src;
1563 if (best_index_src == -1) {
1565 best_nor_dot = -1.0f;
1571 const IndexRange face_src = faces_src[best_index_src];
1572 for (plidx_src = 0; plidx_src < face_src.
size(); plidx_src++) {
1573 const int vert_src = corner_verts_src[face_src.
start() + plidx_src];
1574 if (vert_src == nearest_vert_src) {
1575 best_index_src = plidx_src + int(face_src.
start());
1580 best_nor_dot = (best_nor_dot + 1.0f) * 0.5f;
1581 islands_res[tindex][plidx_dst].
factor = hit_dist ? (best_nor_dot / hit_dist) : 1e18f;
1582 islands_res[tindex][plidx_dst].
hit_dist = hit_dist;
1583 islands_res[tindex][plidx_dst].
index_src = best_index_src;
1587 islands_res[tindex][plidx_dst].
factor = 0.0f;
1589 islands_res[tindex][plidx_dst].
index_src = -1;
1596 copy_v3_v3(tmp_co, vert_positions_dst[vert_dst]);
1600 if (space_transform) {
1607 tdata, &rayhit, tmp_co, tmp_no, ray_radius /
w, max_dist, &hit_dist))
1609 islands_res[tindex][plidx_dst].
factor = (hit_dist ? (1.0f / hit_dist) : 1e18f) *
w;
1610 islands_res[tindex][plidx_dst].
hit_dist = hit_dist;
1611 islands_res[tindex][plidx_dst].
index_src = tri_faces[rayhit.
index];
1612 copy_v3_v3(islands_res[tindex][plidx_dst].hit_point, rayhit.
co);
1625 copy_v3_v3(tmp_co, vert_positions_dst[vert_dst]);
1629 if (space_transform) {
1635 islands_res[tindex][plidx_dst].
factor = 0.0f;
1638 tdata, &nearest, tmp_co, max_dist_sq, &hit_dist))
1640 islands_res[tindex][plidx_dst].
hit_dist = hit_dist;
1641 islands_res[tindex][plidx_dst].
index_src = tri_faces[nearest.
index];
1642 copy_v3_v3(islands_res[tindex][plidx_dst].hit_point, nearest.
co);
1647 islands_res[tindex][plidx_dst].
index_src = -1;
1652 copy_v3_v3(tmp_co, vert_positions_dst[vert_dst]);
1656 if (space_transform) {
1662 islands_res[tindex][plidx_dst].
factor = hit_dist ? (1.0f / hit_dist) : 1e18f;
1663 islands_res[tindex][plidx_dst].
hit_dist = hit_dist;
1664 islands_res[tindex][plidx_dst].
index_src = tri_faces[nearest.
index];
1665 copy_v3_v3(islands_res[tindex][plidx_dst].hit_point, nearest.
co);
1669 islands_res[tindex][plidx_dst].
factor = 0.0f;
1671 islands_res[tindex][plidx_dst].
index_src = -1;
1691 int *face_island_index_map =
nullptr;
1692 int pidx_src_prev = -1;
1695 float best_island_fac = 0.0f;
1696 int best_island_index = -1;
1698 for (tindex = 0; tindex < num_trees; tindex++) {
1699 float island_fac = 0.0f;
1701 for (plidx_dst = 0; plidx_dst < face_dst.
size(); plidx_dst++) {
1702 island_fac += islands_res[tindex][plidx_dst].
factor;
1706 if (island_fac > best_island_fac) {
1707 best_island_fac = island_fac;
1708 best_island_index = tindex;
1712 if (best_island_index != -1 && isld_steps_src) {
1713 best_island = use_islands ? island_store.
islands[best_island_index] :
nullptr;
1714 as_graph = &as_graphdata[best_island_index];
1715 face_island_index_map =
static_cast<int *
>(as_graph->
custom_data);
1719 for (plidx_dst = 0; plidx_dst < face_dst.
size(); plidx_dst++) {
1721 lidx_dst = plidx_dst + int(face_dst.
start());
1723 if (best_island_index == -1) {
1731 isld_res = &islands_res[best_island_index][plidx_dst];
1732 if (use_from_vert) {
1735 if (lidx_src >= 0) {
1736 pidx_src = loop_to_face_map_src[lidx_src];
1738 if (!
ELEM(pidx_src_prev, -1, pidx_src) && isld_steps_src) {
1739 int pidx_isld_src, pidx_isld_src_prev;
1740 if (face_island_index_map) {
1741 pidx_isld_src = face_island_index_map[pidx_src];
1742 pidx_isld_src_prev = face_island_index_map[pidx_src_prev];
1745 pidx_isld_src = pidx_src;
1746 pidx_isld_src_prev = pidx_src_prev;
1763 int last_valid_pidx_isld_src = -1;
1765 for (
int i = as_solution.
steps - 1; i--;) {
1768 pidx_isld_src = as_solution.
prev_nodes[pidx_isld_src];
1772 last_valid_pidx_isld_src = pidx_isld_src;
1775 if (last_valid_pidx_isld_src != -1) {
1780 copy_v3_v3(tmp_co, vert_positions_dst[corner_verts_dst[lidx_dst]]);
1784 if (space_transform) {
1788 pidx_src = (use_islands ? best_island->
indices[last_valid_pidx_isld_src] :
1789 last_valid_pidx_isld_src);
1790 const IndexRange face_src = faces_src[pidx_src];
1791 for (
const int64_t corner : face_src) {
1792 const int vert_src = corner_verts_src[corner];
1794 if (dist_sq < best_dist_sq) {
1795 best_dist_sq = dist_sq;
1796 lidx_src = int(corner);
1809 pidx_src_prev = pidx_src;
1816 r_map, lidx_dst,
FLT_MAX, best_island_index, 0,
nullptr,
nullptr);
1822 if (pidx_src >= 0) {
1824 int best_loop_index_src;
1826 const IndexRange face_src = faces_src[pidx_src];
1828 if (!
ELEM(pidx_src_prev, -1, pidx_src) && isld_steps_src) {
1829 int pidx_isld_src, pidx_isld_src_prev;
1830 if (face_island_index_map) {
1831 pidx_isld_src = face_island_index_map[pidx_src];
1832 pidx_isld_src_prev = face_island_index_map[pidx_src_prev];
1835 pidx_isld_src = pidx_src;
1836 pidx_isld_src_prev = pidx_src_prev;
1853 int last_valid_pidx_isld_src = -1;
1855 for (
int i = as_solution.
steps - 1; i--;) {
1859 pidx_isld_src = as_solution.
prev_nodes[pidx_isld_src];
1863 last_valid_pidx_isld_src = pidx_isld_src;
1866 if (last_valid_pidx_isld_src != -1) {
1872 const int vert_dst = corner_verts_dst[lidx_dst];
1873 copy_v3_v3(tmp_co, vert_positions_dst[vert_dst]);
1877 if (space_transform) {
1881 pidx_src = (use_islands ? best_island->
indices[last_valid_pidx_isld_src] :
1882 last_valid_pidx_isld_src);
1885 if (face_to_corner_tri_map_src ==
nullptr) {
1887 &face_to_corner_tri_map_src_buff,
1889 tri_faces_src.
data(),
1890 int(tri_faces_src.
size()));
1893 for (j = face_to_corner_tri_map_src[pidx_src].count; j--;) {
1896 corner_tris_src[face_to_corner_tri_map_src[pidx_src].
indices[j]];
1901 positions_src[corner_verts_src[tri[0]]],
1902 positions_src[corner_verts_src[tri[1]]],
1903 positions_src[corner_verts_src[tri[2]]]);
1905 if (dist_sq < best_dist_sq) {
1907 best_dist_sq = dist_sq;
1925 &best_loop_index_src);
1932 &best_loop_index_src,
1957 pidx_src_prev = pidx_src;
1964 r_map, lidx_dst,
FLT_MAX, best_island_index, 0,
nullptr,
nullptr);
1973 for (tindex = 0; tindex < num_trees; tindex++) {
1974 MEM_delete(islands_res[tindex]);
1975 if (isld_steps_src) {
1979 MEM_delete(islands_res);
1981 if (isld_steps_src) {
1982 MEM_delete(as_graphdata);
1986 if (face_to_corner_tri_map_src) {
1987 MEM_delete(face_to_corner_tri_map_src);
1989 if (face_to_corner_tri_map_src_buff) {
1990 MEM_delete(face_to_corner_tri_map_src_buff);
1993 MEM_delete(vcos_interp);
1995 if (indices_interp) {
1996 MEM_delete(indices_interp);
1998 if (weights_interp) {
1999 MEM_delete(weights_interp);
2006 const float max_dist,
2007 const float ray_radius,
2008 const Mesh *mesh_dst,
2015 const float full_weight = 1.0f;
2016 const float max_dist_sq = max_dist * max_dist;
2023 face_normals_dst = mesh_dst->face_normals();
2031 const int index = int(i);
2039 const Span<int> tri_faces = me_src->corner_tri_faces();
2051 if (space_transform) {
2057 const int face_index = tri_faces[nearest.
index];
2074 if (space_transform) {
2080 &treedata, &rayhit, tmp_co, tmp_no, ray_radius, max_dist, &hit_dist))
2082 const int face_index = tri_faces[rayhit.
index];
2097 const size_t numfaces_src = size_t(me_src->
faces_num);
2114 int tot_rays, done_rays = 0;
2115 float face_area_2d_inv, done_area = 0.0f;
2118 float to_pnor_2d_mat[3][3], from_pnor_2d_mat[3][3];
2119 float faces_dst_2d_min[2], faces_dst_2d_max[2], faces_dst_2d_z;
2120 float faces_dst_2d_size[2];
2122 float totweights = 0.0f;
2123 float hit_dist_accum = 0.0f;
2124 int sources_num = 0;
2125 const int tris_num = int(face.
size()) - 2;
2133 if (space_transform) {
2138 std::fill_n(weights,
int(numfaces_src), 0.0f);
2140 if (
size_t(face.
size()) > tmp_face_size) [[unlikely]] {
2141 tmp_face_size = size_t(face.
size());
2142 face_vcos_2d =
static_cast<float (*)[2]
>(
2144 tri_vidx_2d =
static_cast<int (*)[3]
>(
2152 faces_dst_2d_z = pcent_dst[2];
2157 for (j = 0; j < face.
size(); j++) {
2158 const int vert = corner_verts_dst[face[j]];
2159 copy_v3_v3(tmp_co, vert_positions_dst[vert]);
2160 if (space_transform) {
2163 mul_v2_m3v3(face_vcos_2d[j], to_pnor_2d_mat, tmp_co);
2164 minmax_v2v2_v2(faces_dst_2d_min, faces_dst_2d_max, face_vcos_2d[j]);
2169 sub_v2_v2v2(faces_dst_2d_size, faces_dst_2d_max, faces_dst_2d_min);
2172 tot_rays = int((
max_ff(faces_dst_2d_size[0], faces_dst_2d_size[1]) / ray_radius) + 0.5f);
2179 tot_rays *= tot_rays;
2183 face_area_2d_inv = 1.0f /
max_ff(face_area_2d_inv, 1e-9f);
2186 if (face.
size() == 3) {
2187 tri_vidx_2d[0][0] = 0;
2188 tri_vidx_2d[0][1] = 1;
2189 tri_vidx_2d[0][2] = 2;
2191 if (face.
size() == 4) {
2192 tri_vidx_2d[0][0] = 0;
2193 tri_vidx_2d[0][1] = 1;
2194 tri_vidx_2d[0][2] = 2;
2195 tri_vidx_2d[1][0] = 0;
2196 tri_vidx_2d[1][1] = 2;
2197 tri_vidx_2d[1][2] = 3;
2201 face_vcos_2d,
uint(face.
size()), -1,
reinterpret_cast<uint(*)[3]
>(tri_vidx_2d));
2204 for (j = 0; j < tris_num; j++) {
2205 float *v1 = face_vcos_2d[tri_vidx_2d[j][0]];
2206 float *
v2 = face_vcos_2d[tri_vidx_2d[j][1]];
2207 float *v3 = face_vcos_2d[tri_vidx_2d[j][2]];
2213 rays_num =
max_ii(
int(
float(tot_rays) * done_area * face_area_2d_inv + 0.5f) - done_rays,
2215 done_rays += rays_num;
2217 while (rays_num--) {
2223 tmp_co[2] = faces_dst_2d_z;
2229 &treedata, &rayhit, tmp_co, tmp_no, ray_radius /
w, max_dist, &hit_dist))
2231 const int face_index = tri_faces[rayhit.
index];
2232 weights[face_index] +=
w;
2234 hit_dist_accum += hit_dist;
2243 if (totweights > 0.0f) {
2244 for (j = 0; j < int(numfaces_src); j++) {
2249 weights[sources_num] = weights[j] / totweights;
2250 indices[sources_num] = j;
2254 r_map,
int(i), hit_dist_accum / totweights, 0, sources_num, indices, weights);
2262 MEM_delete(tri_vidx_2d);
2263 MEM_delete(face_vcos_2d);
2264 MEM_delete(indices);
2265 MEM_delete(weights);
2269 CLOG_WARN(&
LOG,
"Unsupported mesh-to-mesh face mapping mode (%d)!", mode);
2270 memset(r_map->
items, 0,
sizeof(*r_map->
items) *
size_t(faces_dst.
size()));
2275#undef MREMAP_RAYCAST_APPROXIMATE_NR
2276#undef MREMAP_RAYCAST_APPROXIMATE_FAC
2277#undef MREMAP_RAYCAST_TRI_SAMPLES_MIN
2278#undef MREMAP_RAYCAST_TRI_SAMPLES_MAX
2279#undef MREMAP_DEFAULT_BUFSIZE
CustomData interface, see also DNA_customdata_types.h.
An implementation of the A* (AStar) algorithm to solve shortest path problem.
#define BLI_BITMAP_NEW(_num, _alloc_string)
#define BLI_BITMAP_TEST(_bitmap, _index)
#define BLI_BITMAP_ENABLE(_bitmap, _index)
#define BLI_MEMARENA_STD_BUFSIZE
#define CLOG_WARN(clg_ref,...)
Read Blender memory allocation and freeing.
#define INIT_MINMAX2(min, max)
#define POINTER_FROM_INT(i)
#define UNUSED_VARS_NDEBUG(...)
#define POINTER_AS_INT(i)
#define MEM_realloc_uninitialized(vmemh, len)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
void reinitialize(const int64_t new_size)
static IndexMask from_bits(BitSpan bits, LinearAllocator<> &memory)
constexpr int64_t size() const
constexpr int64_t start() const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T * data() const
constexpr int64_t size() const
void fill(const bool value)
GAttributeReader lookup(const StringRef name) const
std::optional< ClosestPointResult > closest_point(const float3 &point, float radius=std::numeric_limits< float >::max()) const
static Tree from_points(Span< float3 > positions, const IndexMask &mask)
IndexRange index_range() const
float dot(VecOp< float, D >, VecOp< float, D >) RET
#define MREMAP_RAYCAST_TRI_SAMPLES_MIN
#define MREMAP_RAYCAST_TRI_SAMPLES_MAX
#define MREMAP_RAYCAST_APPROXIMATE_NR
#define MREMAP_RAYCAST_APPROXIMATE_FAC
#define MREMAP_DEFAULT_BUFSIZE
int edge_other_vert(const int2 edge, const int vert)
GroupedSpan< int > build_edge_to_face_map(OffsetIndices< int > faces, Span< int > corner_edges, int edges_num, Array< int > &r_offsets, Array< int > &r_indices)
float3 face_center_calc(Span< float3 > vert_positions, Span< int > face_verts)
GroupedSpan< int > build_vert_to_edge_map(Span< int2 > edges, int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
BVHTreeFromMesh bvhtree_from_mesh_corner_tris_ex(Span< float3 > vert_positions, OffsetIndices< int > faces, Span< int > corner_verts, Span< int3 > corner_tris, const IndexMask &faces_mask, bool map_global_indices=true)
T distance(const T &a, const T &b)
T midpoint(const T &a, const T &b)
static bool mesh_remap_bvhtree_query_raycast(bke::BVHTreeFromMesh *treedata, BVHTreeRayHit *rayhit, const float co[3], const float no[3], const float radius, const float max_dist, float *r_hit_dist)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE float len_squared_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void negate_v3_v3(float r[3], const float a[3])
void mul_m3_v3(const float M[3][3], float r[3])
void BKE_mesh_remap_free(MeshPairRemap *map)
float line_point_factor_v3(const float p[3], const float l1[3], const float l2[3])
void BLI_astar_node_init(BLI_AStarGraph *as_graph, int node_index, void *custom_data)
MINLINE int compare_ff_relative(float a, float b, float max_diff, int max_ulps)
void BKE_mesh_remap_calc_edges_from_mesh(int mode, const SpaceTransform *space_transform, float max_dist, float ray_radius, Span< float3 > vert_positions_dst, Span< int2 > edges_dst, const Mesh *me_src, Mesh *me_dst, MeshPairRemap *r_map)
MemArena * BLI_memarena_new(size_t bufsize, const char *name) ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(2) ATTR_MALLOC
@ MREMAP_MODE_VERT_EDGEINTERP_NEAREST
@ MREMAP_MODE_LOOP_NEAREST_LOOPNOR
@ MREMAP_MODE_VERT_POLYINTERP_VNORPROJ
@ MREMAP_MODE_VERT_NEAREST
@ MREMAP_MODE_EDGE_VERT_NEAREST
@ MREMAP_MODE_EDGE_EDGEINTERP_VNORPROJ
@ MREMAP_MODE_VERT_FACE_NEAREST
@ MREMAP_MODE_POLY_POLYINTERP_PNORPROJ
@ MREMAP_MODE_LOOP_NEAREST_POLYNOR
@ MREMAP_MODE_VERT_EDGE_NEAREST
@ MREMAP_MODE_EDGE_NEAREST
@ MREMAP_MODE_VERT_POLYINTERP_NEAREST
@ MREMAP_MODE_LOOP_POLY_NEAREST
@ MREMAP_MODE_POLY_NEAREST
@ MREMAP_MODE_EDGE_POLY_NEAREST
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
int BLI_bvhtree_find_nearest(const BVHTree *tree, const float co[3], BVHTreeNearest *nearest, BVHTree_NearestPointCallback callback, void *userdata)
void BKE_mesh_remap_find_best_match_from_mesh(Span< float3 > vert_positions_dst, const Mesh *me_src, SpaceTransform *r_space_transform)
void copy_m4_m3(float m1[4][4], const float m2[3][3])
void BLI_covariance_m3_v3n(const float(*cos_v3)[3], int cos_v3_num, bool use_sample_correction, float r_covmat[3][3], float r_center[3])
Compute the covariance matrix of given set of 3D coordinates.
bool invert_m3_m3(float inverse[3][3], const float mat[3][3])
void BLI_polyfill_calc(const float(*coords)[2], unsigned int coords_num, int coords_sign, unsigned int(*r_tris)[3])
void mul_v2_m3v3(float r[2], const float M[3][3], const float a[3])
static int mesh_remap_interp_face_data_get(const IndexRange face, const Span< int > corner_verts, const Span< float3 > positions_src, const float point[3], size_t *buff_size, float(**vcos)[3], const bool use_loops, int **indices, float **weights, const bool do_weights, int *r_closest_index)
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
static void mesh_calc_eigen_matrix(const Span< float3 > positions, float r_mat[4][4])
MINLINE int max_ii(int a, int b)
int BLI_bvhtree_ray_cast(const BVHTree *tree, const float co[3], const float dir[3], float radius, BVHTreeRayHit *hit, BVHTree_RayCastCallback callback, void *userdata)
static bool mesh_remap_bvhtree_query_nearest(bke::BVHTreeFromMesh *treedata, BVHTreeNearest *nearest, const float co[3], const float max_dist_sq, float *r_hit_dist)
struct RNG * BLI_rng_new(unsigned int seed)
void BLI_rng_get_tri_sample_float_v2(struct RNG *rng, const float v1[2], const float v2[2], const float v3[2], float r_pt[2]) ATTR_NONNULL()
MINLINE float sqrtf_signed(float f)
MINLINE void mul_v3_fl(float r[3], float f)
void BKE_mesh_remap_init(MeshPairRemap *map, int items_num)
static bool mesh_remap_bvh_query_nearest(const bke::bvh::Tree &tree, const float3 &co, const float max_dist, int *r_index, float *r_hit_dist)
float area_poly_v2(const float verts[][2], unsigned int nr)
static void mesh_remap_item_define(MeshPairRemap *map, const int index, const float, const int island, const int sources_num, const int *indices_src, const float *weights_src)
VecBase< int32_t, 2 > int2
VecBase< int32_t, 3 > int3
bool BLI_astar_graph_solve(BLI_AStarGraph *as_graph, int node_index_src, int node_index_dst, astar_f_cost f_cost_cb, BLI_AStarSolution *r_solution, int max_steps)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
MINLINE float area_tri_v2(const float v1[2], const float v2[2], const float v3[2])
void BLI_astar_node_link_add(BLI_AStarGraph *as_graph, int node1_index, int node2_index, float cost, void *custom_data)
void minmax_v2v2_v2(float min[2], float max[2], const float vec[2])
void BLI_space_transform_global_from_matrices(struct SpaceTransform *data, const float local[4][4], const float target[4][4])
void BKE_mesh_origindex_map_create_corner_tri(MeshElemMap **r_map, int **r_mem, OffsetIndices< int > faces, const int *corner_tri_faces, int corner_tris_num)
void BLI_astar_solution_free(BLI_AStarSolution *as_solution)
void unit_m4(float m[4][4])
void BKE_mesh_remap_calc_loops_from_mesh(int mode, const SpaceTransform *space_transform, float max_dist, float ray_radius, const Mesh *mesh_dst, Span< float3 > vert_positions_dst, Span< int > corner_verts_dst, const OffsetIndices< int > faces_dst, const Mesh *me_src, MeshRemapIslandsCalc gen_islands_src, float islands_precision_src, MeshPairRemap *r_map)
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
void BLI_rng_free(struct RNG *rng) ATTR_NONNULL(1)
void interp_weights_poly_v3(float w[], float v[][3], int n, const float co[3])
bool BLI_eigen_solve_selfadjoint_m3(const float m3[3][3], float r_eigen_values[3], float r_eigen_vectors[3][3])
Compute the eigen values and/or vectors of given 3D symmetric (aka adjoint) matrix.
void BKE_mesh_remap_calc_faces_from_mesh(int mode, const SpaceTransform *space_transform, float max_dist, float ray_radius, const Mesh *mesh_dst, Span< float3 > vert_positions_dst, Span< int > corner_verts, const OffsetIndices< int > faces_dst, const Mesh *me_src, MeshPairRemap *r_map)
float BKE_mesh_remap_calc_difference_from_mesh(const SpaceTransform *space_transform, Span< float3 > vert_positions_dst, const Mesh *me_src)
void interp_v3_v3v3_slerp_safe(float target[3], const float a[3], const float b[3], float t)
static void mesh_island_to_astar_graph(MeshIslandStore *islands, const int island_index, const Span< float3 > positions, const GroupedSpan< int > edge_to_face_map, const int numedges, const OffsetIndices< int > faces, const Span< int > corner_verts, const Span< int > corner_edges, BLI_AStarGraph *r_as_graph)
void * BLI_memarena_alloc(MemArena *ma, size_t size) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC ATTR_ALLOC_SIZE(2)
static void mesh_island_to_astar_graph_edge_process(MeshIslandStore *islands, const int island_index, BLI_AStarGraph *as_graph, const Span< float3 > positions, const OffsetIndices< int > faces, const Span< int > corner_verts, const int edge_idx, BLI_bitmap *done_edges, const GroupedSpan< int > edge_to_face_map, const bool is_edge_innercut, const int *face_island_index_map, float(*face_centers)[3], uchar *face_status)
void unit_m3(float m[3][3])
ATTR_WARN_UNUSED_RESULT const BMVert * v2
MINLINE float max_ff(float a, float b)
void BKE_mesh_loop_islands_free(MeshIslandStore *island_store)
void BLI_astar_solution_init(BLI_AStarGraph *as_graph, BLI_AStarSolution *as_solution, void *custom_data)
void closest_on_tri_to_point_v3(float r[3], const float p[3], const float v1[3], const float v2[3], const float v3[3])
bool(*)(Span< float3 > vert_positions, Span< int2 > edges, Span< bool > uv_seams, OffsetIndices< int > faces, Span< int > corner_verts, Span< int > corner_edges, MeshIslandStore *r_island_store) MeshRemapIslandsCalc
void BLI_astar_graph_init(BLI_AStarGraph *as_graph, int node_num, void *custom_data)
void BLI_space_transform_apply(const struct SpaceTransform *data, float co[3])
void copy_m4_m4(float m1[4][4], const float m2[4][4])
VecBase< float, 3 > float3
void ortho_basis_v3v3_v3(float r_n1[3], float r_n2[3], const float n[3])
void BKE_mesh_remap_item_define_invalid(MeshPairRemap *map, int index)
void BLI_space_transform_apply_normal(const struct SpaceTransform *data, float no[3])
void BKE_mesh_remap_calc_verts_from_mesh(int mode, const SpaceTransform *space_transform, float max_dist, float ray_radius, Span< float3 > vert_positions_dst, const Mesh *me_src, Mesh *me_dst, MeshPairRemap *r_map)
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
static float mesh_remap_calc_loops_astar_f_cost(BLI_AStarGraph *as_graph, BLI_AStarSolution *as_solution, BLI_AStarGNLink *link, const int node_idx_curr, const int node_idx_next, const int node_idx_dst)
MINLINE int min_ii(int a, int b)
void BLI_astar_solution_clear(BLI_AStarSolution *as_solution)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
void * BLI_memarena_calloc(MemArena *ma, size_t size) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC ATTR_ALLOC_SIZE(2)
void axis_dominant_v3_to_m3(float r_mat[3][3], const float normal[3])
Normal to x,y matrix.
void BLI_memarena_free(MemArena *ma) ATTR_NONNULL(1)
int isect_line_line_v3(const float v1[3], const float v2[3], const float v3[3], const float v4[3], float r_i1[3], float r_i2[3])
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void BLI_astar_graph_free(BLI_AStarGraph *as_graph)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
BLI_AStarGNLink ** prev_links
MeshPairRemapItem * items
BVHTree_NearestPointCallback nearest_callback
BVHTree_RayCastCallback raycast_callback