39#include "curve_fit_nd.h"
51 points_to_delete.
slice(range).
fill(
false);
52 int64_t total_points_to_remove = 0;
59 if (sub_range.
size() < 3) {
64 float max_dist = -1.0f;
67 const float dist = dist_function(sub_range.
first(), sub_range.
last(),
index);
68 if (dist > max_dist) {
74 if (max_dist > epsilon) {
77 stack.
push(sub_range.
slice(0, max_index + 1));
78 stack.
push(sub_range.
slice(max_index, sub_range.
size() - max_index));
82 total_points_to_remove += inside_range.
size();
83 points_to_delete.
slice(inside_range).
fill(
true);
86 return total_points_to_remove;
90 const float error_threshold,
96 double total_length = 0.0;
98 total_length +=
math::distance(points[point_i - 1], points[point_i]);
101 if (total_length < 1
e-8) {
110 uint cubic_array_len;
111 int error = curve_fit_cubic_to_points_fl(*points.
data(),
115 CURVE_FIT_CALC_HIGH_QUALITY,
129 if (cubic_array ==
nullptr) {
133 Span<float2> cubic_array_span(
reinterpret_cast<float2 *
>(cubic_array), cubic_array_len * 3);
137 return curve_positions;
141 const float radius_min,
142 const float radius_max,
143 const int samples_max,
144 const float angle_threshold,
150 if (points.
size() == 1) {
155 const int error = curve_fit_corners_detect_fl(*points.
data(),
169 if (corners ==
nullptr) {
173 BLI_assert(samples_max < std::numeric_limits<int>::max());
174 Span<int> indices(
reinterpret_cast<int *
>(corners), corners_len);
184 const float merge_distance,
197 tree, merge_distance,
false, selection_merge_indices.
data());
202 selection.
foreach_index([&](
const int src_index,
const int pos) {
203 const int merge_index = selection_merge_indices[pos];
204 if (merge_index != -1) {
205 const int src_merge_index = selection[merge_index] - points.
first();
206 r_merge_indices[src_index - points.
first()] = src_merge_index;
210 return duplicate_count;
214 const float merge_distance,
220 const int src_point_size = src_curves.
points_num();
221 if (src_point_size == 0) {
234 std::atomic<int> total_duplicate_count = 0;
237 for (const int curve_i : range) {
238 const IndexRange points = points_by_curve[curve_i];
239 merge_indices_per_curve[curve_i].reinitialize(points.size());
241 Array<float> distances_along_curve(points.size() + int(cyclic[curve_i]));
242 distances_along_curve.first() = 0.0f;
243 const Span<float> lengths = src_curves.evaluated_lengths_for_curve(curve_i, cyclic[curve_i]);
244 distances_along_curve.as_mutable_span().drop_front(1).copy_from(lengths);
246 MutableSpan<int> merge_indices = merge_indices_per_curve[curve_i].as_mutable_span();
247 array_utils::fill_index_range<int>(merge_indices);
249 const int duplicate_count = curve_merge_by_distance(points,
250 distances_along_curve,
251 selection.slice_content(points),
255 dst_offsets[curve_i] = points.size() - duplicate_count;
256 total_duplicate_count += duplicate_count;
260 const int dst_point_size = src_point_size - total_duplicate_count;
261 dst_curves.resize(dst_point_size, src_curves.curves_num());
264 int merged_points = 0;
265 Array<int> src_to_dst_indices(src_point_size);
266 for (
const int curve_i : src_curves.curves_range()) {
267 const IndexRange points = points_by_curve[curve_i];
268 const Span<int> merge_indices = merge_indices_per_curve[curve_i].as_span();
270 const int point_i = points.
start() + i;
271 src_to_dst_indices[point_i] = point_i - merged_points;
272 if (merge_indices[i] != i) {
278 Array<int> point_merge_counts(dst_point_size, 0);
279 for (
const int curve_i : src_curves.curves_range()) {
280 const IndexRange points = points_by_curve[curve_i];
281 const Span<int> merge_indices = merge_indices_per_curve[curve_i].as_span();
282 for (
const int i : points.index_range()) {
283 const int merge_index = merge_indices[i];
284 const int point_src = points.start() + merge_index;
285 const int dst_index = src_to_dst_indices[point_src];
286 point_merge_counts[dst_index]++;
290 Array<int> map_offsets_data(dst_point_size + 1);
291 map_offsets_data.as_mutable_span().drop_back(1).copy_from(point_merge_counts);
294 point_merge_counts.fill(0);
296 Array<int> merge_map_indices(src_point_size);
297 for (
const int curve_i : src_curves.curves_range()) {
298 const IndexRange points = points_by_curve[curve_i];
299 const Span<int> merge_indices = merge_indices_per_curve[curve_i].as_span();
300 for (
const int i : points.index_range()) {
301 const int point_i = points.start() + i;
302 const int merge_index = merge_indices[i];
303 const int dst_index = src_to_dst_indices[points.start() + merge_index];
304 merge_map_indices[map_offsets[dst_index].first() + point_merge_counts[dst_index]] = point_i;
305 point_merge_counts[dst_index]++;
309 bke::AttributeAccessor src_attributes = src_curves.attributes();
310 bke::MutableAttributeAccessor dst_attributes = dst_curves.attributes_for_write();
311 src_attributes.foreach_attribute([&](
const bke::AttributeIter &iter) {
312 if (attribute_filter.allow_skip(iter.name)) {
318 bke::GAttributeReader src_attribute = iter.get();
319 const CommonVArrayInfo info = src_attribute.varray.common_info();
321 const bke::AttributeInitValue
init(
GPointer(src_attribute.varray.type(), info.data));
322 if (dst_attributes.add(iter.name, iter.domain, iter.data_type,
init)) {
327 bke::GSpanAttributeWriter dst_attribute = dst_attributes.lookup_or_add_for_write_only_span(
334 dst_attribute.finish();
337 if (dst_curves.nurbs_has_custom_knots()) {
348 const float merge_distance,
354 const float merge_distance_squared = merge_distance * merge_distance;
364 for (const int src_i : range) {
365 const IndexRange points = src_points_by_curve[src_i];
366 const float3 start_pos = src_positions[points.first()];
367 const float3 end_pos = src_positions[points.last()];
368 const float3 start_world = math::transform_point(layer_to_world, start_pos);
369 const float3 end_world = math::transform_point(layer_to_world, end_pos);
371 ED_view3d_project_float_global(
372 ®ion, start_world, screen_start_points[src_i], V3D_PROJ_TEST_NOP);
373 ED_view3d_project_float_global(
374 ®ion, end_world, screen_end_points[src_i], V3D_PROJ_TEST_NOP);
378 for (
const int src_i : src_curves.curves_range()) {
379 if (cyclic[src_i] ==
true) {
387 Array<int> connect_to_curve(src_curves.curves_num(), -1);
388 Array<bool> flip_direction(src_curves.curves_num(),
false);
389 selection.foreach_index(
390 [&](
const int src_i) {
391 const float2 &start_co = screen_start_points[src_i];
392 const float2 &end_co = screen_end_points[src_i];
394 const int start_index = src_i * 2;
395 const int end_index = src_i * 2 + 1;
397 KDTreeNearest<float2> nearest_start, nearest_end;
398 const bool is_start_ok =
403 [&](
const int other,
const float2 & ,
const float dist_sq) {
404 if (start_index == other || dist_sq > merge_distance_squared) {
409 const bool is_end_ok =
414 [&](
const int other,
const float2 & ,
const float dist_sq) {
415 if (end_index == other || dist_sq > merge_distance_squared) {
422 const int curve_index = nearest_start.index / 2;
423 const bool is_end_point = bool(nearest_start.index % 2);
424 if (connect_to_curve[curve_index] < 0) {
425 connect_to_curve[curve_index] = src_i;
426 flip_direction[curve_index] = !is_end_point;
430 const int curve_index = nearest_end.index / 2;
431 const bool is_end_point = bool(nearest_end.index % 2);
432 if (connect_to_curve[src_i] < 0) {
433 connect_to_curve[src_i] = curve_index;
434 flip_direction[curve_index] = is_end_point;
442 src_curves, connect_to_curve, flip_direction, attribute_filter);
448 const int corner_subdivisions,
449 const int src_point_index,
455 const int num_points = 1 << (corner_subdivisions + 2);
456 const float delta_angle = 2 *
M_PI /
float(num_points);
457 const float delta_cos =
math::cos(delta_angle);
458 const float delta_sin =
math::sin(delta_angle);
461 for ([[maybe_unused]]
const int i :
IndexRange(num_points)) {
462 r_perimeter.
append(pt + vec);
463 r_src_indices.
append(src_point_index);
465 const float x = delta_cos * vec.x - delta_sin * vec.y;
466 const float y = delta_sin * vec.x + delta_cos * vec.y;
475 const int corner_subdivisions,
476 const int src_point_index,
480 const float3 vec_from = from - center_pt;
481 const float3 vec_to = to - center_pt;
483 r_perimeter.
append(center_pt);
484 r_src_indices.
append(src_point_index);
488 const float cos_angle =
math::dot(vec_from.xy(), vec_to.xy());
489 const float sin_angle = vec_from.x * vec_to.y - vec_from.y * vec_to.x;
496 const int num_full = (1 << (corner_subdivisions + 1)) + 1;
498 if (num_points < 2) {
499 r_perimeter.
append(center_pt + vec_from);
500 r_src_indices.
append(src_point_index);
503 const float delta_angle =
angle /
float(num_points - 1);
504 const float delta_cos =
math::cos(delta_angle);
505 const float delta_sin =
math::sin(delta_angle);
508 for ([[maybe_unused]]
const int i :
IndexRange(num_points)) {
509 r_perimeter.
append(center_pt + vec);
510 r_src_indices.
append(src_point_index);
512 const float x = delta_cos * vec.x - delta_sin * vec.y;
513 const float y = delta_sin * vec.x + delta_cos * vec.y;
522 const int corner_subdivisions,
524 const int src_point_index,
532 point + normal * radius,
540 r_perimeter.
append(point - normal * radius);
541 r_src_indices.
append(src_point_index);
542 r_perimeter.
append(point + normal * radius);
543 r_src_indices.
append(src_point_index);
558 const float miter_limit_angle,
559 const int corner_subdivisions,
560 const int src_point_index,
568 const float3 normal = {tangent.y, -tangent.x, 0.0f};
569 const float3 normal_prev = {tangent_prev.y, -tangent_prev.x, 0.0f};
571 const float sin_angle = tangent_prev.x * tangent.y - tangent_prev.y * tangent.x;
574 const bool is_outside_corner = (sin_angle >= 0.0f);
577 pt_b + normal * radius,
587 const float3 miter = {avg_tangent.y, -avg_tangent.x, 0.0f};
588 const float miter_invscale =
math::dot(normal, miter);
590 if (is_outside_corner) {
591 const bool is_bevel = -
math::dot(tangent, tangent_prev) >
math::cos(miter_limit_angle);
593 r_perimeter.
append(pt_b + normal_prev * radius);
594 r_perimeter.
append(pt_b + normal * radius);
598 const float3 miter_point = pt_b + miter * radius / miter_invscale;
599 r_perimeter.
append(miter_point);
600 r_src_indices.
append(src_point_index);
605 const float3 miter_point = (radius <
length * miter_invscale &&
606 radius < length_prev * miter_invscale) ?
607 pt_b + miter * radius / miter_invscale :
608 pt_b + miter * radius;
610 r_perimeter.
append(miter_point);
611 r_src_indices.
append(src_point_index);
617 const int corner_subdivisions,
618 const bool is_cyclic,
623 const float outline_offset,
629 const int point_num = points.
size();
630 if (point_num == 0) {
633 if (point_num == 1) {
635 const int perimeter_start = r_perimeter.
size();
636 const int point = points.
first();
637 const float radius = std::max(all_radii[point] + outline_offset, 0.0f);
639 positions.
first(), radius, corner_subdivisions, point, r_perimeter, r_point_indices);
640 const int perimeter_count = r_perimeter.
size() - perimeter_start;
641 if (perimeter_count > 0) {
642 r_point_counts.
append(perimeter_count);
647 auto add_corner = [&](
const int a,
const int b,
const int c) {
648 const int point = points[
b];
649 const float3 pt_a = positions[a];
650 const float3 pt_b = positions[
b];
651 const float3 pt_c = positions[c];
652 const float radius = std::max(all_radii[point] + outline_offset, 0.0f);
653 const float miter_angle = miter_angles[point];
664 auto add_cap = [&](
const int center_i,
const int next_i,
const eGPDstroke_Caps cap_type) {
665 const int point = points[center_i];
666 const float3 ¢er = positions[center_i];
668 const float radius = std::max(all_radii[point] + outline_offset, 0.0f);
670 center, dir, radius, corner_subdivisions, cap_type, point, r_perimeter, r_point_indices);
676 const int perimeter_start = r_perimeter.
size();
679 add_cap(0, 1, start_cap_type);
683 add_corner(i - 1, i, i + 1);
686 add_corner(point_num - 2, point_num - 1, 0);
692 add_cap(0, point_num - 1, end_cap_type);
696 add_cap(point_num - 1, point_num - 2, end_cap_type);
701 add_corner(0, point_num - 1, point_num - 2);
704 add_corner(point_num - i, point_num - i - 1, point_num - i - 2);
707 const int perimeter_count = r_perimeter.
size() - perimeter_start;
708 if (perimeter_count > 0) {
709 r_point_counts.
append(perimeter_count);
717 const int left_perimeter_start = r_perimeter.
size();
718 add_corner(point_num - 1, 0, 1);
720 add_corner(i - 1, i, i + 1);
722 add_corner(point_num - 2, point_num - 1, 0);
723 const int left_perimeter_count = r_perimeter.
size() - left_perimeter_start;
724 if (left_perimeter_count > 0) {
725 r_point_counts.
append(left_perimeter_count);
729 const int right_perimeter_start = r_perimeter.
size();
730 add_corner(0, point_num - 1, point_num - 2);
732 add_corner(point_num - i, point_num - i - 1, point_num - i - 2);
734 add_corner(1, 0, point_num - 1);
735 const int right_perimeter_count = r_perimeter.
size() - right_perimeter_start;
736 if (right_perimeter_count > 0) {
737 r_point_counts.
append(right_perimeter_count);
756 const int corner_subdivisions,
757 const float outline_radius,
758 const float outline_offset,
759 const int material_index)
785 for (const int i : range) {
786 transformed_radii[i] = src_radii[i] * scale;
792 strokes.foreach_index(
794 PerimeterData &
data = thread_data.
local();
796 const bool is_cyclic_curve = src_cyclic[curve_i];
797 const bool use_caps = !is_cyclic_curve;
799 const int prev_point_num =
data.positions.size();
800 const int prev_curve_num =
data.point_counts.size();
801 const IndexRange points = src_curves.points_by_curve()[curve_i];
803 generate_stroke_perimeter(transformed_positions,
819 data.positions.as_mutable_span().drop_front(prev_point_num));
821 data.curve_indices.append_n_times(curve_i,
data.point_counts.size() - prev_curve_num);
825 int dst_curve_num = 0;
826 int dst_point_num = 0;
827 for (
const PerimeterData &
data : thread_data) {
830 dst_curve_num +=
data.point_counts.size();
831 dst_point_num +=
data.positions.size();
834 bke::CurvesGeometry dst_curves(dst_point_num, dst_curve_num);
835 if (dst_point_num == 0 || dst_curve_num == 0) {
839 bke::MutableAttributeAccessor dst_attributes = dst_curves.attributes_for_write();
840 bke::SpanAttributeWriter<bool> dst_cyclic = dst_attributes.lookup_or_add_for_write_span<
bool>(
841 "cyclic", bke::AttrDomain::Curve);
842 bke::SpanAttributeWriter<int> dst_material = dst_attributes.lookup_or_add_for_write_span<
int>(
843 "material_index", bke::AttrDomain::Curve);
844 bke::SpanAttributeWriter<float> dst_radius = dst_attributes.lookup_or_add_for_write_span<
float>(
845 "radius", bke::AttrDomain::Point);
846 bke::SpanAttributeWriter<int> dst_fill_ids = dst_attributes.lookup_or_add_for_write_span<
int>(
847 "fill_id", bke::AttrDomain::Curve);
848 const MutableSpan<int> dst_offsets = dst_curves.offsets_for_write();
849 const MutableSpan<float3> dst_positions = dst_curves.positions_for_write();
851 Array<int> dst_curve_map(dst_curve_num);
852 Array<int> dst_point_map(dst_point_num);
855 int fill_id_to_set = 1;
856 Map<int, int> fill_src_id_to_dst_id;
860 for (
const PerimeterData &data : thread_data) {
862 points = points.after(
data.positions.size());
865 dst_curve_map.as_mutable_span().slice(
curves).copy_from(
data.curve_indices);
867 dst_offsets.slice(
curves).copy_from(
data.point_counts);
868 dst_cyclic.span.slice(
curves).fill(
true);
869 if (material_index >= 0) {
870 dst_material.span.slice(
curves).fill(material_index);
873 for (
const int i :
curves.index_range()) {
874 dst_material.span[
curves[i]] = src_material_index[
data.curve_indices[i]];
878 for (
const int i :
curves.index_range()) {
879 const int dst_curve_i =
curves[i];
880 const int src_curve_i =
data.curve_indices[i];
881 const int src_fill_id = src_fill_ids[src_curve_i];
883 if (src_fill_id == 0) {
884 dst_fill_ids.span[dst_curve_i] = fill_id_to_set;
888 if (
const std::optional<int> dst_fill_id = fill_src_id_to_dst_id.lookup_try(src_fill_id)) {
889 dst_fill_ids.span[dst_curve_i] = *dst_fill_id;
892 dst_fill_ids.span[dst_curve_i] = fill_id_to_set;
893 fill_src_id_to_dst_id.add(src_fill_id, fill_id_to_set);
900 dst_positions.slice(points).copy_from(
data.positions);
901 dst_point_map.as_mutable_span().slice(points).copy_from(
data.point_indices);
902 dst_radius.span.slice(points).fill(outline_radius);
904 offset_indices::accumulate_counts_to_offsets(dst_curves.offsets_for_write());
906 bke::gather_attributes(src_attributes,
907 bke::AttrDomain::Point,
908 bke::AttrDomain::Point,
909 bke::attribute_filter_from_skip_ref({
"position",
"radius"}),
912 bke::gather_attributes(
914 bke::AttrDomain::Curve,
915 bke::AttrDomain::Curve,
916 bke::attribute_filter_from_skip_ref({
"cyclic",
"material_index",
"fill_id"}),
921 dst_material.finish();
923 dst_fill_ids.finish();
924 dst_curves.update_curve_types();
933 const int frame_number)
939 int max_bvh_lines = 0;
940 for (
const int i_drawing : drawings.
index_range()) {
941 if (drawings[i_drawing].frame_number == frame_number) {
942 max_bvh_lines += drawings[i_drawing].drawing.strokes().evaluated_points_num();
947 data.start_positions.reinitialize(max_bvh_lines);
948 data.end_positions.reinitialize(max_bvh_lines);
950 data.drawing_offsets.reinitialize(drawings.
size() + 1);
951 for (
const int i_drawing : drawings.
index_range()) {
953 data.drawing_offsets[i_drawing] = (drawings[i_drawing].frame_number == frame_number ?
958 data.drawing_offsets);
961 for (
const int i_drawing : drawings.
index_range()) {
963 if (drawings[i_drawing].frame_number != frame_number) {
968 const float4x4 layer_to_world =
layer.to_world_space(
object);
977 const IndexRange bvh_index_range = bvh_elements_by_drawing[i_drawing];
984 const bool is_cyclic = cyclic[i_curve];
985 const IndexRange evaluated_points = evaluated_points_by_curve[i_curve];
988 for (
const int i_point : evaluated_points) {
990 vc.
region, evaluated_positions[i_point], projection);
991 start_positions[i_point] = co;
994 const int i_prev_point = (i_point > 0 ? i_point - 1 : evaluated_points.
last());
995 end_positions[i_prev_point] = co;
998 for (
const int i_point : evaluated_points.
drop_back(1)) {
999 const float2 &start = start_positions[i_point];
1000 const float2 &end = end_positions[i_point];
1002 const float bb[6] = {start.x, start.y, 0.0f, end.x, end.y, 0.0f};
1007 const float2 &start = start_positions.
last();
1010 const float bb[6] = {start.x, start.y, 0.0f, end.x, end.y, 0.0f};
1025 data.tree =
nullptr;
1027 data.drawing_offsets.reinitialize(0);
1028 data.start_positions.reinitialize(0);
1029 data.end_positions.reinitialize(0);
1045 struct RaycastArgs {
1057 const RaycastArgs &args = *
static_cast<const RaycastArgs *
>(userdata);
1058 if (
ELEM(
index, args.ignore_index1, args.ignore_index2, args.ignore_index3)) {
1063 const float2 ray_end = ray_start +
float2(ray->direction) * ray->radius;
1064 const float2 &line_start = args.tree_data.start_positions[
index];
1065 const float2 &line_end = args.tree_data.end_positions[
index];
1071 if (dist >= hit->dist) {
1078 hit->no[0] =
result.lambda;
1082 auto do_raycast = [&](
const int index_back,
1084 const int index_forward,
1085 float &r_lambda) ->
bool {
1086 if (index_forward < 0) {
1090 const float2 start = screen_space_positions[
index];
1091 const float2 end = screen_space_positions[index_forward];
1095 RaycastArgs args = {tree_data,
1096 index_back >= 0 ? int(tree_data_range[index_back]) : -1,
1097 int(tree_data_range[
index]),
1098 index_forward >= 0 ? int(tree_data_range[index_forward]) : -1};
1105 if (hit.
index >= 0) {
1106 r_lambda = hit.
no[0];
1113 if (r_first_intersect_factors) {
1114 r_first_intersect_factors->fill(-1.0f);
1116 if (r_last_intersect_factors) {
1117 r_last_intersect_factors->fill(-1.0f);
1121 [&](
const int i_curve) {
1122 const bool is_cyclic = cyclic[i_curve];
1123 const IndexRange points = points_by_curve[i_curve];
1125 for (
const int i_point : points) {
1126 const int i_prev_point = (i_point == points.
first() ? (is_cyclic ? points.
last() : -1) :
1128 const int i_next_point = (i_point == points.
last() ? (is_cyclic ? points.
first() : -1) :
1132 if (do_raycast(i_prev_point, i_point, i_next_point, lambda)) {
1133 r_hits[i_point] =
true;
1134 if (r_first_intersect_factors) {
1135 (*r_first_intersect_factors)[i_point] = lambda;
1139 if (do_raycast(i_next_point, i_point, i_prev_point, lambda)) {
1141 if (r_last_intersect_factors) {
1142 (*r_last_intersect_factors)[i_point] = 1.0f - lambda;
1164 screen_space_positions,
1177 result.segment_offsets.reinitialize(
curves.curves_num() + 1);
1179 result.segment_offsets.fill(0);
1181 [&](
const int curve_i) {
1182 const IndexRange points = points_by_curve[curve_i];
1184 const bool is_cyclic = cyclic[curve_i];
1188 result.segment_offsets[curve_i] = (is_cyclic ? 0 : 1) + curve_hit_mask.
size();
1194 const int num_segments = segments_by_curve.
total_size();
1195 result.segment_start_points.reinitialize(num_segments);
1196 result.segment_start_fractions.reinitialize(num_segments);
1199 [&](
const int curve_i) {
1200 const IndexRange points = points_by_curve[curve_i];
1202 const bool is_cyclic = cyclic[curve_i];
1203 const IndexRange segments = segments_by_curve[curve_i];
1204 const int hit_segments_start = (is_cyclic ? 0 : 1);
1212 result.segment_start_points[segments[0]] = points.
first();
1213 result.segment_start_fractions[segments[0]] = 0.0f;
1216 curve_hit_mask.
foreach_index([&](
const int point_i,
const int hit_i) {
1217 result.segment_start_points[segments[hit_segments_start + hit_i]] = point_i;
1218 result.segment_start_fractions[segments[hit_segments_start + hit_i]] =
1219 first_hit_factors[point_i];
Low-level operations for curves.
Low-level operations for curves.
Low-level operations for grease pencil.
A KD-tree for nearest neighbor search.
#define GP_STROKE_MITER_ANGLE_ROUND
#define BLI_assert_unreachable()
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
MutableSpan< T > as_mutable_span()
Array(Allocator allocator={}) noexcept
IndexRange index_range() const
static IndexMask from_bools(Span< bool > bools, LinearAllocator<> &memory)
static IndexMask from_indices(Span< T > indices, LinearAllocator<> &memory)
constexpr int64_t first() const
constexpr IndexRange drop_back(int64_t n) const
constexpr int64_t last(const int64_t n=0) const
constexpr int64_t size() const
constexpr bool is_empty() const
constexpr int64_t start() const
constexpr IndexRange slice(int64_t start, int64_t size) const
constexpr IndexRange index_range() const
constexpr IndexRange drop_front(int64_t n) const
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
constexpr void fill(const T &value) const
constexpr T & first() const
constexpr T & last(const int64_t n=0) const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T * data() const
constexpr const T & first() const
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
void push(const T &value)
void append(const T &value)
void append_n_times(const T &value, const int64_t n)
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
VArray< bool > cyclic() const
AttributeAccessor attributes() const
Span< float3 > positions() const
IndexRange curves_range() const
void ensure_evaluated_lengths() const
MutableSpan< int > offsets_for_write()
OffsetIndices< int > points_by_curve() const
const bke::CurvesGeometry & strokes() const
VArray< float > radii() const
IndexMask slice_content(IndexRange range) const
void to_indices(MutableSpan< T > r_indices) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
float length(VecOp< float, D >) RET
float3x3 scale(float3x3 mat, float2 scale)
void fill_index_range(MutableSpan< T > span, const T start=0)
void mix_groups(GSpan src, OffsetIndices< int > groups, Span< int > all_indices, std::optional< Span< float > > all_weights, GMutableSpan dst)
void update_custom_knot_modes(const IndexMask &mask, const KnotsMode mode_for_regular, const KnotsMode mode_for_cyclic, bke::CurvesGeometry &curves)
bke::CurvesGeometry copy_only_curve_domain(const bke::CurvesGeometry &src_curves)
void free(Subdiv *subdiv)
void find_curve_intersections(const bke::CurvesGeometry &curves, const IndexMask &curve_mask, const Span< float2 > screen_space_positions, const Curves2DBVHTree &tree_data, const IndexRange tree_data_range, MutableSpan< bool > r_hits, std::optional< MutableSpan< float > > r_first_intersect_factors, std::optional< MutableSpan< float > > r_last_intersect_factors)
bke::CurvesGeometry curves_merge_by_distance(const bke::CurvesGeometry &src_curves, const float merge_distance, const IndexMask &selection, const bke::AttributeFilter &attribute_filter)
int64_t ramer_douglas_peucker_simplify(const IndexRange range, const float epsilon, const FunctionRef< float(int64_t, int64_t, int64_t)> dist_function, MutableSpan< bool > points_to_delete)
static void generate_circle_from_point(const float3 &pt, const float radius, const int corner_subdivisions, const int src_point_index, Vector< float3 > &r_perimeter, Vector< int > &r_src_indices)
static void generate_arc_from_point_to_point(const float3 &from, const float3 &to, const float3 ¢er_pt, const int corner_subdivisions, const int src_point_index, Vector< float3 > &r_perimeter, Vector< int > &r_src_indices)
void free_curves_2d_bvh_data(Curves2DBVHTree &data)
CurveSegmentsData find_curve_segments(const bke::CurvesGeometry &curves, const IndexMask &curve_mask, const Span< float2 > screen_space_positions, const Curves2DBVHTree &tree_data, const IndexRange tree_data_range)
static void generate_corner(const float3 &pt_a, const float3 &pt_b, const float3 &pt_c, const float radius, const float miter_limit_angle, const int corner_subdivisions, const int src_point_index, Vector< float3 > &r_perimeter, Vector< int > &r_src_indices)
IndexMask polyline_detect_corners(Span< float2 > points, const float radius_min, const float radius_max, const int samples_max, const float angle_threshold, IndexMaskMemory &memory)
static void generate_stroke_perimeter(const Span< float3 > all_positions, const Span< float > all_radii, const IndexRange points, const int corner_subdivisions, const bool is_cyclic, const bool use_caps, const eGPDstroke_Caps start_cap_type, const eGPDstroke_Caps end_cap_type, const VArray< float > miter_angles, const float outline_offset, Vector< float3 > &r_perimeter, Vector< int > &r_point_counts, Vector< int > &r_point_indices)
static void generate_cap(const float3 &point, const float3 &tangent, const float radius, const int corner_subdivisions, const eGPDstroke_Caps cap_type, const int src_point_index, Vector< float3 > &r_perimeter, Vector< int > &r_src_indices)
bke::CurvesGeometry curves_merge_endpoints_by_distance(const ARegion ®ion, const bke::CurvesGeometry &src_curves, const float4x4 &layer_to_world, const float merge_distance, const IndexMask &selection, const bke::AttributeFilter &attribute_filter)
Array< float2 > polyline_fit_curve(Span< float2 > points, const float error_threshold, const IndexMask &corner_mask)
Curves2DBVHTree build_curves_2d_bvh_from_visible(const ViewContext &vc, const Object &object, const GreasePencil &grease_pencil, Span< MutableDrawingInfo > drawings, const int frame_number)
int curve_merge_by_distance(const IndexRange points, const Span< float > distances, const IndexMask &selection, const float merge_distance, MutableSpan< int > r_merge_indices)
bke::CurvesGeometry create_curves_outline(const bke::greasepencil::Drawing &drawing, const IndexMask &strokes, const float4x4 &transform, const int corner_subdivisions, const float outline_radius, const float outline_offset, const int material_index)
constexpr ParallelGrainSize grain_size(int grain_size)
bke::CurvesGeometry curves_merge_endpoints(const bke::CurvesGeometry &src_curves, Span< int > connect_to_curve, Span< bool > flip_direction, const bke::AttributeFilter &attribute_filter)
T cos(const AngleRadianBase< T > &a)
isect_result< VecBase< T, Size > > isect_seg_seg(const VecBase< T, Size > &v1, const VecBase< T, Size > &v2, const VecBase< T, Size > &v3, const VecBase< T, Size > &v4)
T distance(const T &a, const T &b)
T length(const VecBase< T, Size > &a)
QuaternionBase< T > normalize_and_get_length(const QuaternionBase< T > &q, T &out_length)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
T average(const VecBase< T, Size > &a)
CartesianBasis invert(const CartesianBasis &basis)
T atan2(const T &y, const T &x)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
VecBase< T, 3 > to_scale(const MatBase< T, NumCol, NumRow > &mat)
T sin(const AngleRadianBase< T > &a)
void transform_points(const float4x4 &transform, MutableSpan< float3 > points, bool use_threading=true)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void(*)(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit) BVHTree_RayCastCallback
void kdtree_balance(KDTree< CoordT > *tree)
void BLI_bvhtree_free(BVHTree *tree)
int kdtree_find_nearest_cb(const KDTree< CoordT > *tree, const CoordT &co, KDTreeNearest< CoordT > *r_nearest, Filter &&filter_cb)
void BLI_bvhtree_balance(BVHTree *tree)
float2 ED_view3d_project_float_v2_m4(const ARegion *region, const float co[3], const float4x4 &mat)
MatBase< float, 4, 4 > float4x4
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)
KDTree< CoordT > * kdtree_new(uint nodes_len_capacity)
VecBase< float, 2 > float2
BMesh const char void * data
void kdtree_insert(KDTree< CoordT > *tree, int index, const CoordT &co)
BVHTree * BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis)
void kdtree_free(KDTree< CoordT > *tree)
void BKE_defgroup_copy_list(ListBaseT< bDeformGroup > *outbase, const ListBaseT< bDeformGroup > *inbase)
void BLI_bvhtree_insert(BVHTree *tree, int index, const float co[3], int numpoints)
int kdtree_calc_duplicates_fast(const KDTree< CoordT > *tree, const typename KDTree< CoordT >::ValueType range, const bool use_index_order, int *duplicates)
float4x4 ED_view3d_ob_project_mat_get_from_obmat(const RegionView3D *rv3d, const float4x4 &obmat)
VecBase< float, 3 > float3
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
ListBaseT< struct bDeformGroup > vertex_group_names
static constexpr int type_length
bke::greasepencil::Drawing & drawing
Vector< int > point_counts
Vector< int > point_indices
Vector< float3 > positions
Vector< int > curve_indices