ଦୁଇଟି ଇରେଜର, ଏବଂ କାହିଁକି ମୋଛା କାର୍ଯ୍ୟ ଷ୍ଟ୍ରୋକ୍‌ର ମାଲିକାନାରେ ରହେ

ଲୋକେ ନୋଟବୁକ୍‌ରେ ମୋଛୁଥିବାବେଳେ ଦୁଇଟି ଭିନ୍ନ କଥା ବୁଝାନ୍ତି। କେବେ ଗୋଟିଏ ଚିହ୍ନ ଭୁଲ ହୁଏ ଏବଂ ସମ୍ପୂର୍ଣ୍ଣ ଚିହ୍ନଟି ହଟିଯିବା ଉଚିତ: ଗୋଟିଏ guide line, କାଟିଦିଆଯାଇଥିବା ଶବ୍ଦ, କିମ୍ବା ବିଶ୍ରାମ ନେଇଥିବା ହାତରୁ ହୋଇଥିବା ଅନାବଶ୍ୟକ stroke। ଆଉ କେବେ ଗୋଟିଏ ଚିହ୍ନର କେବଳ କିଛି ଅଂଶ ଭୁଲ ହୁଏ: ଗୋଟିଏ ଅକ୍ଷରର ଅଧା, ଗୋଟିଏ diagram ର ଏକ ଶାଖା, କିମ୍ବା ବାକ୍ୟକୁ ଅତିକ୍ରମ କରିଯାଇଥିବା highlighter sweep ର ଲାଞ୍ଜ। Lulucat Notes ଏବେ ଦୁଇଟିକୁ ଅଲଗା ଅଲଗା tool ଭାବରେ ଦିଏ।

ଅଧିକ କଠିନ ଡିଜାଇନ୍ ପ୍ରଶ୍ନ ହେଉଛି: ମୋଛା କାର୍ଯ୍ୟ କେଉଁଠି ରହିବ।

ଷ୍ଟ୍ରୋକ୍ ଇରେଜର ପ୍ରଥମେ ଆସିଥିଲା

ପ୍ରଥମ ଇରେଜର ସମ୍ପୂର୍ଣ୍ଣ stroke ଡିଲିଟ୍ କରୁଥିଲା। ଗୋଟିଏ touch ପ୍ରତ୍ୟେକ stroke କୁ ପରୀକ୍ଷା କରେ: bounding boxes ପ୍ରାୟ ସମସ୍ତକୁ ବାଦ ଦିଏ, ଏବଂ ବଞ୍ଚିଥିବା stroke ଗୁଡ଼ିକ ପାଇଁ eraser radius ସହ ସେହି segment ଉପରେ interpolate କରାଯାଇଥିବା stroke radius ର ଯୋଗ ସହ point-to-segment squared distance test ଚାଲେ। Width pressure ସହ ବଦଳୁଥାଏ, ତେଣୁ ଗୋଟିଏ nominal width ବ୍ୟବହାର କଲେ user ଛୁଇଁନଥିବା ପତଳା stroke ଡିଲିଟ୍ ହୋଇଯାଏ ଏବଂ ଛୁଇଁଥିବା ମୋଟା stroke ଛାଡ଼ିଯାଏ।

ଗୋଟିଏ gesture ଗୋଟିଏ undo entry ରେ ମିଶିଯାଏ, ଏବଂ ସେହି entry ପ୍ରତ୍ୟେକ ହଟାଯାଇଥିବା stroke କୁ ତାହାର original index ସହ ସଞ୍ଚୟ କରେ। Undo ସେଗୁଡ଼ିକୁ reverse order ରେ ପୁଣି insert କରେ, ତେଣୁ stacking order ଠିକ୍ ପୂର୍ବର ଭଳି ଫେରିଆସେ।

ଏହି ଇରେଜର ଦ୍ରୁତ, ପୂର୍ବାନୁମାନଯୋଗ୍ୟ, ଏବଂ ଗୋଟିଏ ଶବ୍ଦର ଅଧା ହଟାଇପାରେ ନାହିଁ।

MaLiang ଇରେଜରକୁ brush କରିଦିଏ

MaLiang, ଯେଉଁ MIT-ଲାଇସେନ୍ସପ୍ରାପ୍ତ drawing framework ଠାରୁ ଆମେ ପୂର୍ବରୁ highlighter stamp model ନେଇଥିଲୁ, partial erasing ର ଉତ୍ତର 24ଟି line ରେ ଦିଏ। ଏହାର Eraser ହେଉଛି Brush ର ଏକ subclass, ଯାହା କେବଳ blend options କୁ override କରି add ବଦଳରେ subtract କରେ। ଗୋଟିଏ eraser stroke ଅନ୍ୟ ସମସ୍ତ stroke ପରି ସେହି list ରେ ଥିବା ଏକ element। Undo ସେହି element କୁ ହଟାଏ। କୌଣସି existing stroke ବଦଳାଯାଏ ନାହିଁ, କାରଣ list order ରେ replay କରିବା ସମୟରେ ମାତ୍ର ମୋଛା କାର୍ଯ୍ୟ ହୁଏ।

ଆମେ ସେହି model କୁ ship କଲୁ, ଏବଂ ଦୁଇଟି device session ଏହାକୁ ଭାଙ୍ଗିଦେଲା।

Object move ଅଦୃଶ୍ୟ owner କୁ ପ୍ରକାଶ କରେ

ପ୍ରଥମ report: lasso ଦ୍ୱାରା stroke ବାଛି ସେଗୁଡ଼ିକୁ drag କଲେ hole ପଛରେ ରହିଯାଏ।

ସେହି ମୋଛାଯାଇଥିବା stroke ଗୁଡ଼ିକୁ ଡାହାଣକୁ ନେଇଯାଇଛି। ଉପରେ: ଇରେଜର ନିଜର ଏକ element। ତଳେ: ମୋଛା କାର୍ଯ୍ୟ stroke ଗୁଡ଼ିକର ମାଲିକାନାରେ।

Selection ସମସ୍ୟାଟିକୁ ଆହୁରି ଖରାପ କଲା। Selected stroke ଗୁଡ଼ିକ bitmap ରୁ ଏକ overlay ଭିତରକୁ ଉଠିଯାଆନ୍ତି, ଯେଉଁଠାରେ eraser element ବିନା ସେମାନେ ସିଧାସଳଖ ଅଙ୍କାଯାଆନ୍ତି। ତେଣୁ ଆପଣ ଯେତେବେଳେ ଗୋଟିଏ ମୋଛାଯାଇଥିବା stroke ବାଛନ୍ତି, ସେହି ମୁହୂର୍ତ୍ତରେ ସେ ପୁଣି ସମ୍ପୂର୍ଣ୍ଣ ଦେଖାଯାଏ।

ଦ୍ୱିତୀୟ report: eraser highlighter ଉପରେ ଭାସୁଥିଲା। ଆମ renderer ଦୁଇଟି pass ରେ replay କରେ, highlighter ପ୍ରଥମେ ଏବଂ pen ପରେ, କାରଣ highlighter ink କୁ ink ତଳେ ରହିବାକୁ ପଡ଼େ। ଗୋଟିଏ eraser element କୁ ଉଭୟ pass ରେ ଭାଗ ନେବାକୁ ପଡ଼େ, ନହେଲେ ସେ ଉଭୟ ପ୍ରକାରର stroke ମୋଛିପାରିବ ନାହିଁ। Pen pass ରେ ଭାଗ ନେବାର ଅର୍ଥ ହେଉଛି ପ୍ରତ୍ୟେକ highlighter ଅଙ୍କାଯିବା ପରେ ଏହା ଚାଲିବ, ତେଣୁ eraser ସମୟକ୍ରମରେ ପରେ ଅଙ୍କାଯାଇଥିବା highlighter stroke ମଧ୍ୟ କାଟିଦିଏ।

ଉଭୟ ବିଫଳତାର ଉତ୍ସ ଏକ। MaLiang ରେ lasso, move, କିମ୍ବା brush ମଧ୍ୟରେ layer order ନାହିଁ, ତେଣୁ owner ନଥିବା element ସେଠାରେ ପର୍ଯ୍ୟାପ୍ତ। ଆମ canvas ରେ ଏହି ତିନୋଟି ଅଛି, ଏବଂ owner ନଥିବା ଏକ erasure ପାଇଁ “ink move ହେଲେ କ’ଣ ହୁଏ” କିମ୍ବା “ଏହା କେଉଁ layer ଉପରେ କାମ କରୁଛି” ପ୍ରଶ୍ନର କୌଣସି ନିର୍ଦ୍ଧାରିତ ଉତ୍ତର ନାହିଁ।

ଷ୍ଟ୍ରୋକ୍‌ର ମାଲିକାନାରେ ମୋଛା କାର୍ଯ୍ୟ

ପ୍ରତ୍ୟେକ Stroke ଏବେ ନିଜର erase paths ବହନ କରେ। ଇରେଜର ଯେଉଁ stroke ଗୁଡ଼ିକୁ ଛୁଏ ସେଗୁଡ଼ିକୁ ପରୀକ୍ଷା କରି, canvas coordinates ରେ ପ୍ରତ୍ୟେକ stroke ରେ ଗୋଟିଏ path ଯୋଡ଼େ। ଗୋଟିଏ stroke ରେଣ୍ଡର କରିବାବେଳେ transparency layer ଭିତରେ ତାହାର ink ଏବଂ ନିଜର erasures ଅଙ୍କାଯାଏ:

context.beginTransparencyLayer(auxiliaryInfo: nil)
drawInk(stroke, in: context, clip: clip, colorOverride: colorOverride)
context.setBlendMode(.destinationOut)
for path in stroke.erasePaths { fillErasePath(path, in: context) }
context.endTransparencyLayer()

Destination-out destination କୁ ରଖେ ଏବଂ source alpha ର ଅନୁପାତରେ ତାହାକୁ ହଟାଏ:

ଗୋଟିଏ transparency layer ଭିତରେ destination ହେଉଛି ସେହି ଏକ stroke, ତେଣୁ ଏହି operation paper, ତଳେ ଥିବା stroke, କିମ୍ବା ପରେ ଅଙ୍କାଯାଇଥିବା stroke ପର୍ଯ୍ୟନ୍ତ ପହଞ୍ଚିପାରେ ନାହିଁ। Erasure ନଥିବା stroke ପାଇଁ layer ର କୌଣସି ଖର୍ଚ୍ଚ ନାହିଁ, ଏବଂ ସେମାନେ ପ୍ରାୟ ସମସ୍ତେ: ସେମାନେ original path ନେଇଥାନ୍ତି।

Ownership ଦୁଇଟି ବିଫଳତାର ସିଧା ଉତ୍ତର ଦିଏ। Translation sample point ଗୁଡ଼ିକ ସହ erase path କୁ ମଧ୍ୟ ନେଇଯାଏ, ତେଣୁ ଚଳାଯାଇଥିବା stroke ନିଜର gap ସହ ଚାଲିଯାଏ। Selection overlay ସେହି stroke object କୁ ଅଙ୍କେ, ତେଣୁ selected stroke ରେ ମଧ୍ୟ ସେହି gap ଦେଖାଯାଏ। Layer order ଆଉ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ରହେ ନାହିଁ, କାରଣ ଗୋଟିଏ erasure ନିଜର stroke ବ୍ୟତୀତ ଅନ୍ୟ କୌଣସି ଜିନିଷରେ ଲାଗେ ନାହିଁ।

Undo gesture ଉପରେ କାମ କରେ: ଗୋଟିଏ entry ସେହି gesture ତିଆରି କରିଥିବା ପ୍ରତ୍ୟେକ (stroke, path) pair ର ତାଲିକା ରଖେ, undo ସେହି path ଗୁଡ଼ିକୁ ହଟାଏ, ଏବଂ redo ସେଗୁଡ଼ିକୁ ପୁଣି append କରେ। Erasure ତଳେ ଥିବା ink କେବେ edit ହୁଏ ନାହିଁ, ତେଣୁ କିଛି reconstruct କରିବାକୁ ପଡ଼େ ନାହିଁ।

Live feedback tile bitmap ମାଧ୍ୟମରେ ଯାଏ

ଯେଉଁ stroke ଅଙ୍କାଯାଉଛି ତାହା ସାଧାରଣତଃ composited page ଉପରେ ଥିବା ଏକ overlay ଭାବରେ ରେଣ୍ଡର ହୁଏ। ଏଠାରେ erasure କାମ କରିପାରେ ନାହିଁ, କାରଣ ସେହି overlay paper ସହିତ ink ଉପରେ ମଧ୍ୟ ବସିଥାଏ, ଏବଂ destination-out paper ଭିତରେ ମଧ୍ୟ ଗର୍ତ୍ତ କରିଦେଇଥାନ୍ତା।

ତେଣୁ eraser ତୁରନ୍ତ stroke ଭିତରେ ଲେଖେ, ଏବଂ ନୂଆ sample ର ପ୍ରତ୍ୟେକ batch କେବଳ ପ୍ରଭାବିତ rectangle ର ସ୍ଥାନୀୟ replay କୁ ଚାଲୁ କରେ। Tile pipeline ପୂର୍ବରୁ ଗୋଟିଏ rectangle କୁ clear କରି ସେଥିରେ intersect କରୁଥିବା stroke ଗୁଡ଼ିକୁ replay କରେ; eraser ସେହି path କୁ ପୁଣି ବ୍ୟବହାର କରେ ଏବଂ ଦ୍ୱିତୀୟ drawing semantic ଯୋଡ଼େ ନାହିଁ।

ଦୁଇଟି ଇରେଜର, ପାଖାପାଖି

Toolbar ରେ ଲୁଚା ଥିବା mode ସହ ଗୋଟିଏ button ନୁହେଁ, ଦୁଇଟି eraser button ଅଛି। Partial eraser ଗୋଟିଏ stroke ର କିଛି ଅଂଶ ହଟାଏ। Stroke eraser ସ୍ପର୍ଶ କଲେ ସମ୍ପୂର୍ଣ୍ଣ stroke ହଟାଏ। ସେମାନଙ୍କ radius ଅଲଗା constant, ଏବଂ ଏବେ ଉଭୟ 4 points।

ଗୋଟିଏ ସମ୍ପୂର୍ଣ୍ଣ stroke ଡିଲିଟ୍ କଲେ ତାହାର erase paths ମଧ୍ୟ ସେଥିସହ ଚାଲିଯାଏ, କାରଣ ସେଗୁଡ଼ିକ ସେହି stroke ର ଅଂଶ; undo ଉଭୟକୁ ଏକାଠି ଫେରାଇ ଆଣେ। Erase paths saved file ର ମଧ୍ୟ ଅଂଶ, ଏବଂ ଅନ୍ୟ ସବୁକିଛି ପରି quantize କରାଯାଏ: radius ଓ coordinates ଗୋଟିଏ point ର ଦଶମାଂଶ ଭାବରେ।

ଗୋଟିଏ ସୀମାବଦ୍ଧତା ଏପର୍ଯ୍ୟନ୍ତ ରହିଛି। ଗୋଟିଏ stroke କୁ ସମ୍ପୂର୍ଣ୍ଣ ମୋଛି ଶୂନ୍ୟ କରିଦେଲେ ମଧ୍ୟ ସେ data ଭାବରେ ରହିଥାଏ। Render ରେ ଏହା କିଛି ଦେଖାଏ ନାହିଁ, କିନ୍ତୁ lasso ଏପର୍ଯ୍ୟନ୍ତ ଏହାକୁ select କରିପାରେ, stroke eraser ଏହାକୁ ଡିଲିଟ୍ କରିପାରେ, ଏବଂ ଏହା document ରେ ସ୍ଥାନ ଦଖଲ କରିଥାଏ। ସମ୍ପୂର୍ଣ୍ଣ ମୋଛାଯାଇଥିବା stroke ସଂଗ୍ରହ କରିବା ପାଇଁ ଏକ coverage test ଦରକାର, ଯାହା ଆମେ ଏପର୍ଯ୍ୟନ୍ତ ଲେଖିନାହୁଁ, ତେଣୁ ବର୍ତ୍ତମାନ ସେଗୁଡ଼ିକ ରହିଥାଏ।

ଅନ୍ୟ ଏକ project ର model ଆପଣଙ୍କ project ରେ କାମ କରିବା ବନ୍ଦ କଲେ, ତଫାତ ସାଧାରଣତଃ ଆପଣ କପି କରିଥିବା code ରେ ନଥାଏ। ତଫାତ ଥାଏ ସେହି project ରେ ନଥିବା feature ଗୁଡ଼ିକରେ।