Cosmetic tap markings: look for their cylinder only in nearby bodies (#10303)
* Holes and cuts: count the bodies a cut works on in the cost tests A test helper, cut_work, adds a feature at the end of a design and reports how many bodies its cut ran booleans on and which bodies it left exactly as they were (same geometry, key and face names). A new test pins that a cut still goes through the boolean where its tool touches a face, runs along an edge, passes a hair beside a body or drills into a dome. The sheet metal hole (#10226) and cosmetic thread (#10227) work reuse the helper for their own shortcuts. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Holes and cuts: leave bodies the tool cannot reach untouched without a full cut A cut ran a whole boolean against every body of its component, and for a body its tool does not reach that boolean only handed the body back: about 7 ms per body, so a hole in a design of 200 blocks took 1.3 s. Now a body whose box lies clear of every tool's box is left as it is. Both boxes are their meshes' grown past how far the exact faces can curve out from them, the same test sheet metal cuts already use, so a tool that touches a body, grazes it or drills into a dome still goes through the boolean. Bodies shown in another frame, mesh bodies and Intersect (which removes the bodies it misses) are unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Cosmetic tap markings: look for their cylinder only in nearby bodies A tap marking (a Thread feature, or the marking of a tapped hole) looked for the cylinder at its point in every body of the design, and each search meshes the body afresh: with many bodies and many markings that grew quadratically (200 markings on 200 cylinders: 33 s of a 33 s run). A body is now passed over when its box, from the mesh it keeps and grown past that mesh's deflection, lies farther from the point than the search itself would look (a twentieth of the body's size, plus its own mesh's deflection). The search finds no face there, so the marking and everything else stay the same. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
committed by
GitHub
parent
b470d46ffc
commit
12ebc80e15
+25
-1
@@ -465,7 +465,12 @@ fn thread_on_impl(
|
||||
let (body, cyl) = st
|
||||
.bodies
|
||||
.iter()
|
||||
.filter_map(|b| kernel::cylinder_face_at(&b.body, p).map(|c| (b.name.clone(), c)))
|
||||
.filter(|b| !more::beyond_cylinder_reach(b, p))
|
||||
.filter_map(|b| {
|
||||
#[cfg(test)]
|
||||
cost_tests::count(|c| c.cylinder_search += 1);
|
||||
kernel::cylinder_face_at(&b.body, p).map(|c| (b.name.clone(), c))
|
||||
})
|
||||
.min_by(|a, b| {
|
||||
let dist = |c: &kernel::CylinderFace| ((p - c.axis_point - c.axis * (p - c.axis_point).dot(c.axis)).len() - c.radius).abs();
|
||||
dist(&a.1).total_cmp(&dist(&b.1))
|
||||
@@ -3308,10 +3313,29 @@ fn apply_traced_with(
|
||||
let affected: std::collections::BTreeMap<String, usize> =
|
||||
target_idx.iter().filter_map(|i| state.bodies.get(*i)).map(|b| (b.name.clone(), b.body.lumps().map_or(1, |l| l.len()))).collect();
|
||||
let mut remove = Vec::new();
|
||||
// A cut hands a body its tools cannot reach back as it was, but only after a whole
|
||||
// boolean: in a design of many bodies that was most of a hole's time (#10225). Such a
|
||||
// body is left as it is. Its box and the tools' are their meshes' grown past how far
|
||||
// the exact faces can curve out from them (a dome rises above the outline of its
|
||||
// edges), so a tool that touches a body, or only comes near it, still meets it in the
|
||||
// boolean. A body shown in another frame, and a mesh body, are cut as before; an
|
||||
// intersect removes the bodies it misses, and is left as it was.
|
||||
let reach: Option<Vec<Option<solidcraft_geom::Aabb3>>> =
|
||||
(op == Operation::Cut && !tools.iter().any(|t| t.body.is_mesh())).then(|| tools.iter().map(|t| more::body_box(&t.body)).collect());
|
||||
for &ti in &target_idx {
|
||||
let Some(mut acc) = state.bodies.get(ti).map(|b| Some(b.traced())) else { continue };
|
||||
// The tools meet the target where it is shown: in its frame (#3383).
|
||||
let into = state.bodies.get(ti).and_then(|b| tool_frame(&b.name));
|
||||
if let (Some(reach), None, Some(mb)) = (&reach, into, state.bodies.get(ti))
|
||||
&& !reach.is_empty()
|
||||
&& !mb.body.is_mesh()
|
||||
&& let Some(target) = more::mesh_box(mb)
|
||||
&& reach.iter().all(|tool| more::boxes_apart(&Some(target), tool))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
#[cfg(test)]
|
||||
cost_tests::count(|c| c.cut += 1);
|
||||
for t in &tools {
|
||||
let t = &tool_in(t, into)?;
|
||||
acc = match acc {
|
||||
|
||||
@@ -16,7 +16,8 @@ use crate::eval::{PlacementReads, body_world, hash_placement, placement_digest};
|
||||
use crate::*;
|
||||
|
||||
/// Work counted on this thread: bodies moved, STEP texts digested, joint faces and bodies
|
||||
/// measured, bodies searched for by name, features searched for by id.
|
||||
/// measured, bodies searched for by name, features searched for by id, bodies a cut (or
|
||||
/// intersect) ran its booleans on, and bodies searched for the cylinder a tap marking lies on.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq)]
|
||||
pub(super) struct Counts {
|
||||
pub moved: usize,
|
||||
@@ -25,11 +26,23 @@ pub(super) struct Counts {
|
||||
pub measures: usize,
|
||||
pub body_searches: usize,
|
||||
pub feature_searches: usize,
|
||||
pub cut: usize,
|
||||
pub cylinder_search: usize,
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
static COUNTS: Cell<Counts> =
|
||||
const { Cell::new(Counts { moved: 0, digested: 0, joint_faces: 0, measures: 0, body_searches: 0, feature_searches: 0 }) };
|
||||
static COUNTS: Cell<Counts> = const {
|
||||
Cell::new(Counts {
|
||||
moved: 0,
|
||||
digested: 0,
|
||||
joint_faces: 0,
|
||||
measures: 0,
|
||||
body_searches: 0,
|
||||
feature_searches: 0,
|
||||
cut: 0,
|
||||
cylinder_search: 0,
|
||||
})
|
||||
};
|
||||
}
|
||||
|
||||
pub(super) fn count(f: impl FnOnce(&mut Counts)) {
|
||||
@@ -1083,3 +1096,251 @@ fn a_placed_tap_follows_its_body_offset() {
|
||||
apply_point(&mat_mul(&doc.component_transform(comp), &rigid(Vec3::new(0.0, 0.0, 7.0), Vec3::ZERO, Vec3::Z, 0.0)), Vec3::new(1.0, 1.0, 0.0));
|
||||
assert!(tap.axis_point.dist(expected) < 1e-9, "{:?} {expected:?}", tap.axis_point);
|
||||
}
|
||||
|
||||
/// What adding a feature of `kind` at the end of `doc` did to the bodies already there: how many
|
||||
/// its cut ran booleans on, and which it left exactly as they were (the same geometry, its name,
|
||||
/// key and face names carried over). A cut that cannot reach a body hands it back as it was, and
|
||||
/// must not pay a whole boolean to find that out (#10225); the sheet metal hole (#10226) and the
|
||||
/// cosmetic thread (#10227) check their own shortcuts with it too.
|
||||
pub(super) struct CutWork {
|
||||
pub cut: usize,
|
||||
pub kept: Vec<String>,
|
||||
pub model: Model,
|
||||
}
|
||||
|
||||
pub(super) fn cut_work(doc: &mut Document, kind: FeatureKind) -> CutWork {
|
||||
let mut model = Model::new();
|
||||
model.evaluate(doc);
|
||||
let id = doc.add_feature(kind, None).unwrap();
|
||||
let work = counted(|| model.evaluate(doc));
|
||||
let result = model.result(id).unwrap();
|
||||
assert_eq!(result.error, None, "the feature builds");
|
||||
let before = model.state_before(id);
|
||||
let kept = result
|
||||
.state
|
||||
.bodies
|
||||
.iter()
|
||||
.filter(|b| {
|
||||
before
|
||||
.body(&b.name)
|
||||
.is_some_and(|old| old.body.same(&b.body) && old.key == b.key && crate::naming::face_names(old) == crate::naming::face_names(b))
|
||||
})
|
||||
.map(|b| b.name.clone())
|
||||
.collect();
|
||||
CutWork { cut: work.cut, kept, model }
|
||||
}
|
||||
|
||||
/// A box body named `name`, `size` long on each side from `corner`.
|
||||
fn block(doc: &mut Document, name: &str, corner: Vec3, size: [f64; 3]) {
|
||||
let id = doc
|
||||
.add_feature(
|
||||
FeatureKind::Box {
|
||||
corner: point_expr(corner),
|
||||
length: size[0].to_string().into(),
|
||||
width: size[1].to_string().into(),
|
||||
height: size[2].to_string().into(),
|
||||
operation: Operation::NewBody,
|
||||
},
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
doc.feature_mut(id).unwrap().body_names = vec![name.into()];
|
||||
}
|
||||
|
||||
/// A cylinder that cuts, standing on `base` along Z.
|
||||
fn cutter(base: Vec3, radius: f64, height: f64) -> FeatureKind {
|
||||
FeatureKind::Cylinder {
|
||||
base: point_expr(base),
|
||||
axis: Dir(Vec3::Z),
|
||||
radius: radius.to_string().into(),
|
||||
height: height.to_string().into(),
|
||||
operation: Operation::Cut,
|
||||
references: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// A cut leaves the bodies its tool cannot reach as they were, without a boolean on each: in a
|
||||
/// design of many bodies those booleans were most of a hole's time (#10225).
|
||||
#[test]
|
||||
fn a_cut_leaves_bodies_it_cannot_reach_as_they_were() {
|
||||
let mut doc = Document::new("far");
|
||||
block(&mut doc, "Near", Vec3::ZERO, [50.0, 40.0, 30.0]);
|
||||
// 0.5 mm clear of the tool, and far off.
|
||||
block(&mut doc, "Beside", Vec3::new(13.5, 0.0, 0.0), [20.0, 40.0, 30.0]);
|
||||
for i in 0..5 {
|
||||
block(&mut doc, &format!("Far{i}"), Vec3::new(200.0 * (i + 1) as f64, 0.0, 0.0), [50.0, 40.0, 30.0]);
|
||||
}
|
||||
// Near and Beside overlap; the hole goes through Near only, beside Beside.
|
||||
let work = cut_work(&mut doc, cutter(Vec3::new(10.0, 20.0, -5.0), 3.0, 40.0));
|
||||
assert_eq!(work.cut, 1, "only the body the tool reaches goes through the boolean");
|
||||
assert_eq!(work.kept, ["Beside", "Far0", "Far1", "Far2", "Far3", "Far4"]);
|
||||
assert!(volume(&work.model, "Near") < 60_000.0 - 800.0, "and it is cut");
|
||||
}
|
||||
|
||||
/// A cut still goes through the boolean wherever its tool reaches a body or comes close: on a
|
||||
/// face, along a line, a hair beside it, into a dome above its edge circle. (Bodies its tool
|
||||
/// cannot reach are left out of it: `a_cut_leaves_bodies_it_cannot_reach_as_they_were`.)
|
||||
#[test]
|
||||
fn a_cut_still_runs_where_its_tool_touches_grazes_or_meets_a_curved_face() {
|
||||
// A cylinder whose side is tangent to the face x = 50, one a hair clear of it, one 0.1 mm in.
|
||||
for (x, cuts) in [(53.0, false), (53.0005, false), (52.9, true)] {
|
||||
let mut doc = Document::new("graze");
|
||||
block(&mut doc, "A", Vec3::ZERO, [50.0, 40.0, 30.0]);
|
||||
let work = cut_work(&mut doc, cutter(Vec3::new(x, 20.0, 0.0), 3.0, 30.0));
|
||||
assert_eq!(work.cut, 1, "the tool at x = {x} goes through the boolean");
|
||||
let v = volume(&work.model, "A");
|
||||
assert_eq!(v < 60_000.0 - 1.0, cuts, "the tool at x = {x} cuts material: {v}");
|
||||
assert!(!cuts || work.kept.is_empty(), "a body cut is a new body");
|
||||
}
|
||||
// A box meeting the block only along its top edge.
|
||||
let mut doc = Document::new("edge");
|
||||
block(&mut doc, "A", Vec3::ZERO, [50.0, 40.0, 30.0]);
|
||||
let along = FeatureKind::Box {
|
||||
corner: point_expr(Vec3::new(50.0, 0.0, 30.0)),
|
||||
length: "10".into(),
|
||||
width: "40".into(),
|
||||
height: "10".into(),
|
||||
operation: Operation::Cut,
|
||||
};
|
||||
assert_eq!(cut_work(&mut doc, along).cut, 1);
|
||||
// A dome: a sphere's cap rising 10 mm above the circle it stands on. A thin tool drilled into
|
||||
// its top near the apex, well above that circle, cuts it.
|
||||
let mut doc = Document::new("dome");
|
||||
doc.add_feature(FeatureKind::Sphere { center: point_expr(Vec3::new(0.0, 0.0, -10.0)), radius: "20".into(), operation: Operation::NewBody }, None)
|
||||
.unwrap();
|
||||
let below = FeatureKind::Box {
|
||||
corner: point_expr(Vec3::new(-30.0, -30.0, -40.0)),
|
||||
length: "60".into(),
|
||||
width: "60".into(),
|
||||
height: "40".into(),
|
||||
operation: Operation::Cut,
|
||||
};
|
||||
doc.add_feature(below, None).unwrap();
|
||||
let mut model = Model::new();
|
||||
model.evaluate(&doc);
|
||||
let dome = model.state().bodies[0].name.clone();
|
||||
let whole = volume(&model, &dome);
|
||||
let work = cut_work(&mut doc, cutter(Vec3::new(2.0, 1.0, 8.0), 1.0, 5.0));
|
||||
assert_eq!(work.cut, 1);
|
||||
assert!(volume(&work.model, &dome) < whole - 1.0, "the drill cuts into the dome");
|
||||
assert!(work.kept.is_empty());
|
||||
}
|
||||
|
||||
/// A cylinder body named `name` standing on `base` along Z.
|
||||
fn shaft(doc: &mut Document, name: &str, base: Vec3, radius: f64, height: f64) {
|
||||
let id = doc
|
||||
.add_feature(
|
||||
FeatureKind::Cylinder {
|
||||
base: point_expr(base),
|
||||
axis: Dir(Vec3::Z),
|
||||
radius: radius.to_string().into(),
|
||||
height: height.to_string().into(),
|
||||
operation: Operation::NewBody,
|
||||
references: Vec::new(),
|
||||
},
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
doc.feature_mut(id).unwrap().body_names = vec![name.into()];
|
||||
}
|
||||
|
||||
/// The work of adding `kind` at the end of `doc`, and the tap markings the design then has.
|
||||
fn marking_work(doc: &mut Document, kind: FeatureKind) -> (Counts, Vec<ThreadInfo>) {
|
||||
let mut model = Model::new();
|
||||
model.evaluate(doc);
|
||||
let id = doc.add_feature(kind, None).unwrap();
|
||||
let work = counted(|| model.evaluate(doc));
|
||||
assert_eq!(model.result(id).unwrap().error, None, "the feature builds");
|
||||
(work, model.state().threads.clone())
|
||||
}
|
||||
|
||||
/// A cosmetic tap marking at `p`.
|
||||
fn marking(p: Vec3) -> FeatureKind {
|
||||
FeatureKind::Thread { face: FacePick(p), designation: Some("M6".into()), length: None, modeled: false, handedness: ThreadHandedness::Right }
|
||||
}
|
||||
|
||||
/// A tap marking looks for its cylinder in the bodies near it only: each body searched was
|
||||
/// tessellated again, so many markings in a design of many bodies took quadratic time (#10227).
|
||||
#[test]
|
||||
fn a_tap_marking_searches_only_the_bodies_near_it() {
|
||||
let mut doc = Document::new("far");
|
||||
shaft(&mut doc, "Shaft", Vec3::ZERO, 3.0, 6.0);
|
||||
for i in 0..5 {
|
||||
block(&mut doc, &format!("Far{i}"), Vec3::new(200.0 * (i + 1) as f64, 0.0, 0.0), [50.0, 40.0, 30.0]);
|
||||
}
|
||||
let (work, threads) = marking_work(&mut doc, marking(Vec3::new(3.0, 0.0, 3.0)));
|
||||
assert_eq!(work.cylinder_search, 1, "only the shaft is searched");
|
||||
assert_eq!(threads.len(), 1);
|
||||
assert_eq!(threads[0].body, "Shaft");
|
||||
assert_eq!(threads[0].designation, "M6");
|
||||
assert!((threads[0].radius - 3.0).abs() < 1e-6 && !threads[0].internal);
|
||||
|
||||
// A tapped hole in a plate among far bodies: only the plate is searched for its wall.
|
||||
let mut doc = Document::new("tapped");
|
||||
block(&mut doc, "Plate", Vec3::ZERO, [60.0, 60.0, 12.0]);
|
||||
for i in 0..5 {
|
||||
block(&mut doc, &format!("Far{i}"), Vec3::new(200.0 * (i + 1) as f64, 0.0, 0.0), [50.0, 40.0, 30.0]);
|
||||
}
|
||||
let hole = FeatureKind::Hole {
|
||||
position: FacePick(Vec3::new(30.0, 30.0, 12.0)),
|
||||
at: None,
|
||||
direction: Dir(-Vec3::Z),
|
||||
diameter: "5".into(),
|
||||
depth: Some("10".into()),
|
||||
hole: HoleKind::default(),
|
||||
points: None,
|
||||
thread: Some("M6".into()),
|
||||
thread_depth: None,
|
||||
handedness: ThreadHandedness::Right,
|
||||
to: None,
|
||||
references: Vec::new(),
|
||||
};
|
||||
let (work, threads) = marking_work(&mut doc, hole);
|
||||
assert_eq!(work.cylinder_search, 1, "only the plate is searched");
|
||||
assert_eq!(threads.len(), 1);
|
||||
assert_eq!(threads[0].body, "Plate");
|
||||
assert!(threads[0].internal && (threads[0].radius - 2.5).abs() < 1e-6);
|
||||
}
|
||||
|
||||
/// Bodies within reach of a tap marking are still searched: the shaft it lies on, a block 3 mm
|
||||
/// off (within a twentieth of the block's size, where the cylinder search itself looks), and one
|
||||
/// 3.6 mm off (just past it, but within the margin the boxes keep); a block 4.5 mm off is not.
|
||||
/// The marking stays on the shaft.
|
||||
#[test]
|
||||
fn a_tap_marking_still_searches_the_bodies_within_its_reach() {
|
||||
let mut doc = Document::new("near");
|
||||
shaft(&mut doc, "Shaft", Vec3::ZERO, 3.0, 6.0);
|
||||
// Each block is 50 x 40 x 30 (a twentieth of its size is 3.54 mm), its face x = 3 + gap.
|
||||
for (name, gap) in [("Close", 3.0), ("Edge", 3.6), ("Clear", 4.5)] {
|
||||
block(&mut doc, name, Vec3::new(3.0 + gap, -20.0, 0.0), [50.0, 40.0, 30.0]);
|
||||
}
|
||||
let (work, threads) = marking_work(&mut doc, marking(Vec3::new(3.0, 0.0, 3.0)));
|
||||
assert_eq!(work.cylinder_search, 3, "the shaft, Close and Edge are searched");
|
||||
assert_eq!(threads.len(), 1);
|
||||
assert_eq!(threads[0].body, "Shaft");
|
||||
|
||||
// A pin in a hole a hair wider: a marking on the pin, and one on the hole's wall.
|
||||
for (p, body, internal) in [(Vec3::new(2.0, 0.0, 5.0), "Pin", false), (Vec3::new(2.5, 0.0, 5.0), "Plate", true)] {
|
||||
let mut doc = Document::new("pin");
|
||||
block(&mut doc, "Plate", Vec3::new(-20.0, -20.0, 0.0), [40.0, 40.0, 10.0]);
|
||||
let bore = FeatureKind::Cylinder {
|
||||
base: point_expr(Vec3::new(0.0, 0.0, -1.0)),
|
||||
axis: Dir(Vec3::Z),
|
||||
radius: "2.5".into(),
|
||||
height: "12".into(),
|
||||
operation: Operation::Cut,
|
||||
references: Vec::new(),
|
||||
};
|
||||
doc.add_feature(bore, None).unwrap();
|
||||
shaft(&mut doc, "Pin", Vec3::ZERO, 2.0, 10.0);
|
||||
let mut kind = marking(p);
|
||||
if let FeatureKind::Thread { designation, .. } = &mut kind {
|
||||
*designation = None;
|
||||
}
|
||||
let (work, threads) = marking_work(&mut doc, kind);
|
||||
assert_eq!(work.cylinder_search, 2, "both bodies are searched for {body}");
|
||||
assert_eq!(threads.len(), 1);
|
||||
assert_eq!(threads[0].body, body);
|
||||
assert_eq!(threads[0].internal, internal);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1569,13 +1569,13 @@ fn sheet_prism_cut(
|
||||
|
||||
/// A box around `body`, grown past its mesh's deflection from the exact faces (and a hair
|
||||
/// more): bodies whose boxes are apart do not meet. None when it can't be worked out.
|
||||
fn body_box(body: &Body) -> Option<Aabb3> {
|
||||
pub(super) fn body_box(body: &Body) -> Option<Aabb3> {
|
||||
let tol = (body.size() * 1e-3).max(1e-4);
|
||||
padded_box(&body.tessellate(tol).ok()?, tol)
|
||||
}
|
||||
|
||||
/// [`body_box`] of a model body, from the mesh it keeps.
|
||||
fn mesh_box(mb: &ModelBody) -> Option<Aabb3> {
|
||||
pub(super) fn mesh_box(mb: &ModelBody) -> Option<Aabb3> {
|
||||
padded_box(&mb.mesh(), mb.display_tol())
|
||||
}
|
||||
|
||||
@@ -1584,8 +1584,25 @@ fn padded_box(mesh: &solidcraft_geom::Mesh, tol: f64) -> Option<Aabb3> {
|
||||
(!b.is_empty() && b.min.is_finite() && b.max.is_finite()).then(|| b.inflated(2.0 * tol + 1e-6))
|
||||
}
|
||||
|
||||
/// Whether [`kernel::cylinder_face_at`] is known to find no face of `mb` at `p`. It takes a
|
||||
/// face only when its own mesh of the body comes within a twentieth of the body's size of the
|
||||
/// point. That mesh lies in the body's box ([`mesh_box`]) give or take its own deflection, which
|
||||
/// the reach allows for, so a box farther away than that holds no face for it. Working that out from the mesh the body keeps
|
||||
/// spares a tessellation of every body in the design for each tap marking (#10227). A mesh
|
||||
/// body, and a body whose box is unknown, are searched as before.
|
||||
pub(super) fn beyond_cylinder_reach(mb: &ModelBody, p: Vec3) -> bool {
|
||||
if mb.body.is_mesh() {
|
||||
return false;
|
||||
}
|
||||
let Some(b) = mesh_box(mb) else { return false };
|
||||
let size = mb.body.size();
|
||||
let reach = size * 0.05 + 2.0 * (size * 1e-3).max(1e-3);
|
||||
let off = (b.min - p).max(p - b.max).max(Vec3::ZERO);
|
||||
off.len() > reach
|
||||
}
|
||||
|
||||
/// Whether two boxes are known to be apart (an unknown box is never apart).
|
||||
fn boxes_apart(a: &Option<Aabb3>, b: &Option<Aabb3>) -> bool {
|
||||
pub(super) fn boxes_apart(a: &Option<Aabb3>, b: &Option<Aabb3>) -> bool {
|
||||
let (Some(a), Some(b)) = (a, b) else { return false };
|
||||
a.max.x < b.min.x || b.max.x < a.min.x || a.max.y < b.min.y || b.max.y < a.min.y || a.max.z < b.min.z || b.max.z < a.min.z
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user