ಎರಡು ಎರೇಸರ್‌ಗಳು, ಅಳಿಸುವಿಕೆ ಸ್ಟ್ರೋಕ್‌ಗೆ ಸೇರಿರುವುದೇಕೆ

ನೋಟ್‌ಬುಕ್‌ನಲ್ಲಿ ಏನನ್ನಾದರೂ ಅಳಿಸುವಾಗ, ಜನರು ಎರಡು ಬೇರೆ ಕೆಲಸಗಳನ್ನು ಉದ್ದೇಶಿಸುತ್ತಾರೆ. ಕೆಲವೊಮ್ಮೆ ಒಂದು ಗುರುತು ತಪ್ಪಾಗಿರುತ್ತದೆ ಮತ್ತು ಆ ಗುರುತು ಸಂಪೂರ್ಣವಾಗಿ ಹೋಗಬೇಕು: ಒಂದು ಮಾರ್ಗದರ್ಶಕ ರೇಖೆ, ಗೆರೆ ಹಾಕಿದ ಪದ, ಅಥವಾ ವಿಶ್ರಾಂತಿಯಲ್ಲಿ ಇಟ್ಟ ಕೈಯಿಂದ ಉಳಿದ ಅನಿರೀಕ್ಷಿತ stroke. ಕೆಲವೊಮ್ಮೆ ಗುರುತಿನ ಒಂದು ಭಾಗ ಮಾತ್ರ ತಪ್ಪಾಗಿರುತ್ತದೆ: ಅಕ್ಷರದ ಅರ್ಧ ಭಾಗ, diagramನ ಒಂದು branch, ಅಥವಾ ವಾಕ್ಯವನ್ನು ದಾಟಿಹೋದ highlighter sweepನ tail. Lulucat Notes ಈಗ ಇವೆರಡನ್ನೂ ಎರಡು ಪ್ರತ್ಯೇಕ tools ಆಗಿ ಒದಗಿಸುತ್ತದೆ.

ಹೆಚ್ಚು ಕಷ್ಟವಾದ ವಿನ್ಯಾಸದ ಪ್ರಶ್ನೆ ಪಿಕ್ಸೆಲ್‌ಗಳನ್ನು ಹೇಗೆ ತೆಗೆದುಹಾಕುವುದು ಎಂಬುದಲ್ಲ. ಅಳಿಸುವಿಕೆ ಎಲ್ಲಿ ಇರಬೇಕು ಎಂಬುದೇ ಪ್ರಶ್ನೆ.

ಸ್ಟ್ರೋಕ್ ಎರೇಸರ್ ಮೊದಲು ಬಂದಿತು

ಮೊದಲ ಎರೇಸರ್ ಸಂಪೂರ್ಣ strokes ಅನ್ನು ಅಳಿಸುತ್ತಿತ್ತು. ಪ್ರತಿಯೊಂದು touchನಲ್ಲಿ ಎಲ್ಲಾ strokes ಅನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತದೆ: bounding boxes ಬಹುತೇಕ ಎಲ್ಲವನ್ನೂ reject ಮಾಡುತ್ತವೆ, ಮತ್ತು ಉಳಿದವುಗಳಿಗೆ eraser radius ಹಾಗೂ ಆ segment ಉದ್ದಕ್ಕೂ interpolate ಮಾಡಿದ stroke radiusನ ಮೊತ್ತದ ವಿರುದ್ಧ point-to-segment squared distance test ನಡೆಯುತ್ತದೆ. Pressure ಪ್ರಕಾರ width ಬದಲಾಗುತ್ತದೆ; ಆದ್ದರಿಂದ ಒಂದೇ nominal width ಬಳಸಿದರೆ ಬಳಕೆದಾರ ತಾಗಿಸದ ತೆಳುವಾದ strokes ಅಳಿಸಿಬಿಡುತ್ತದೆ ಮತ್ತು ತಾಗಿಸಿದ ದಪ್ಪ strokes ಅನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

ಒಂದು gesture ಒಂದೇ undo entry ಆಗಿ ಸೇರುತ್ತದೆ. ಆ entry ಅಳಿಸಿದ ಪ್ರತಿಯೊಂದು stroke ಅನ್ನು ಅದರ original index ಜೊತೆಗೆ ಉಳಿಸುತ್ತದೆ. Undo ಅವುಗಳನ್ನು reverse orderನಲ್ಲಿ ಮತ್ತೆ insert ಮಾಡುತ್ತದೆ, ಹೀಗಾಗಿ stacking order ನಿಖರವಾಗಿ ಹಿಂದಿನಂತೆಯೇ ಮರಳುತ್ತದೆ.

ಈ ಎರೇಸರ್ ವೇಗವಾದುದು, ಊಹಿಸಬಹುದಾದುದು, ಆದರೆ ಪದದ ಅರ್ಧವನ್ನು ಅಳಿಸಲಾರದು.

MaLiang ಎರೇಸರ್ ಅನ್ನು brush ಆಗಿಸುತ್ತದೆ

MaLiang ನಾವು ಈಗಾಗಲೇ highlighter stamp model ಅನ್ನು borrow ಮಾಡಿಕೊಂಡಿರುವ MIT-licensed drawing framework; ಅದು partial erasingಗೆ 24 linesನಲ್ಲಿ ಉತ್ತರ ನೀಡುತ್ತದೆ. ಇದರ Eraser ಒಂದು Brush subclass. ಅದು blend options ಎಂಬ ಒಂದೇ ವಿಷಯವನ್ನು override ಮಾಡಿ, add ಮಾಡುವ ಬದಲು subtract ಮಾಡುತ್ತದೆ. Eraser stroke ಇತರ ಎಲ್ಲ strokesಗಳಂತೆಯೇ ಅದೇ listನಲ್ಲಿರುವ element. Undo ಆ element ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ. ಈಗಿರುವ ಯಾವುದೇ stroke ಬದಲಾಗುವುದಿಲ್ಲ, ಏಕೆಂದರೆ erasure replay ಸಮಯದಲ್ಲಿ list orderನಲ್ಲಿ ಮಾತ್ರ ನಡೆಯುತ್ತದೆ.

ನಾವು ಆ model ಅನ್ನು ship ಮಾಡಿದೆವು, ಮತ್ತು ಎರಡು device sessionsನಲ್ಲಿ ಅದು ಮುರಿಯಿತು.

Object move ಮಾಲೀಕನ ಕೊರತೆಯನ್ನು ಬಯಲಿಗೆಳೆಯುತ್ತದೆ

ಮೊದಲ ವರದಿ ಹೀಗಿತ್ತು: lasso ಬಳಸಿ strokes ಅನ್ನು select ಮಾಡಿ drag ಮಾಡಿದರೆ, hole ಹಿಂದಿನ ಜಾಗದಲ್ಲೇ ಉಳಿಯುತ್ತದೆ.

ಅದೇ erased strokes ಅನ್ನು ಬಲಕ್ಕೆ move ಮಾಡಲಾಗಿದೆ. ಮೇಲೆ: eraser ತನ್ನದೇ element. ಕೆಳಗೆ: erasure strokeಗೆ ಸೇರಿದೆ.

Selection ಇದನ್ನು ಇನ್ನಷ್ಟು ಕೆಟ್ಟದಾಗಿಸಿತು. Selected strokes bitmapನಿಂದ overlayಗೆ lift ಆಗಿ, eraser element ಇಲ್ಲದೆ ನೇರವಾಗಿ draw ಆಗುತ್ತವೆ. ಆದ್ದರಿಂದ erased stroke ಅನ್ನು select ಮಾಡಿದ ಕ್ಷಣದಲ್ಲೇ ಅದು ಮತ್ತೆ ಸಂಪೂರ್ಣವಾಗಿ ಕಾಣಿಸಿತು.

ಎರಡನೇ ವರದಿ: eraser highlighter ಮೇಲ್ಭಾಗದಲ್ಲಿ ತೇಲುತ್ತಿತ್ತು. Highlighter ink ಸಾಮಾನ್ಯ inkನ ಕೆಳಗಿರಬೇಕಾದ್ದರಿಂದ ನಮ್ಮ renderer ಎರಡು passesನಲ್ಲಿ replay ಮಾಡುತ್ತದೆ: ಮೊದಲು highlighters, ನಂತರ pens. Eraser element ಎರಡೂ passesನಲ್ಲಿ ಭಾಗವಹಿಸಬೇಕು; ಇಲ್ಲದಿದ್ದರೆ ಅದು ಎರಡೂ ವಿಧದ strokes ಅನ್ನು erase ಮಾಡಲಾರದು. Pen passನಲ್ಲಿ ಭಾಗವಹಿಸುವುದೆಂದರೆ ಪ್ರತಿ highlighter draw ಆದ ನಂತರ ಅದು run ಆಗುವುದು. ಹೀಗಾಗಿ eraser ಸಮಯದಲ್ಲಿ ನಂತರ draw ಮಾಡಲಾದ highlighter strokesನ್ನೂ ಕತ್ತರಿಸಿಬಿಡುತ್ತಿತ್ತು.

ಎರಡೂ failuresಗೆ ಒಂದೇ ಮೂಲವಿದೆ. MaLiangನಲ್ಲಿ lasso, move ಅಥವಾ brushes ನಡುವಿನ layer order ಯಾವುದೂ ಇಲ್ಲ; ಆದ್ದರಿಂದ owner ಇಲ್ಲದ element ಅಲ್ಲಿ ಸಾಕಾಗುತ್ತದೆ. ನಮ್ಮ canvasನಲ್ಲಿ ಈ ಮೂರೂ ಇವೆ, ಮತ್ತು owner ಇಲ್ಲದ erasureಗೆ “ink move ಆದಾಗ ಏನಾಗುತ್ತದೆ” ಅಥವಾ “ಇದು ಯಾವ layer ಮೇಲೆ ಕೆಲಸ ಮಾಡುತ್ತಿದೆ” ಎಂಬ ಪ್ರಶ್ನೆಗಳಿಗೆ defined answer ಇಲ್ಲ.

Strokeಗೆ ಸೇರಿದ erasure

ಪ್ರತಿಯೊಂದು Stroke ಈಗ ತನ್ನದೇ erase paths ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ. Eraser ಯಾವ strokesಗೆ ತಾಗುತ್ತದೆ ಎಂದು ಪರೀಕ್ಷಿಸಿ, ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದಕ್ಕೂ canvas coordinatesನಲ್ಲಿ ಒಂದು path ಅನ್ನು append ಮಾಡುತ್ತದೆ. ಒಂದು stroke ಅನ್ನು render ಮಾಡುವಾಗ ಅದರ ink ಮತ್ತು ಅದರದೇ erasures ಅನ್ನು transparency layer ಒಳಗೆ draw ಮಾಡಲಾಗುತ್ತದೆ:

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, ಕೆಳಗಿನ strokes, ಅಥವಾ ನಂತರ draw ಆಗುವ strokesಗಳಿಗೆ ತಲುಪಲಾರದು. Erasures ಇಲ್ಲದ strokesಗೆ layer ವೆಚ್ಚವೇ ಇಲ್ಲ; ಅವು ಬಹುತೇಕ ಎಲ್ಲವೂ, ಮತ್ತು ಅವು original path ಬಳಸುತ್ತವೆ.

Ownership ಎರಡೂ failuresಗೆ ನೇರವಾಗಿ ಉತ್ತರಿಸುತ್ತದೆ. Translation erase paths ಅನ್ನು sample points ಜೊತೆ move ಮಾಡುತ್ತದೆ, ಹೀಗಾಗಿ moved stroke ತನ್ನ gaps ಅನ್ನು ಜೊತೆಗೆ ಕೊಂಡೊಯ್ಯುತ್ತದೆ. Selection overlay ಅದೇ stroke object ಅನ್ನು draw ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ selected stroke ಅದೇ gaps ಅನ್ನು ತೋರಿಸುತ್ತದೆ. Layer order ಮುಖ್ಯವಾಗುವುದಿಲ್ಲ, ಏಕೆಂದರೆ erasure ತನ್ನದೇ stroke ಹೊರತು ಬೇರೆ ಯಾವುದಕ್ಕೂ ಅನ್ವಯಿಸುವುದಿಲ್ಲ.

Undo gesture ಮಟ್ಟದಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ: ಒಂದು entryಯಲ್ಲಿ ಆ gesture ಸೃಷ್ಟಿಸಿದ ಪ್ರತಿಯೊಂದು (stroke, path) pair ಪಟ್ಟಿಯಾಗಿರುತ್ತದೆ; undo ಆ paths ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, redo ಅವುಗಳನ್ನು ಮತ್ತೆ append ಮಾಡುತ್ತದೆ. Erasure ಕೆಳಗಿನ ink ಎಂದಿಗೂ edit ಆಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಯಾವುದನ್ನೂ reconstruct ಮಾಡಬೇಕಾಗಿಲ್ಲ.

Live feedback tile bitmap ಮೂಲಕ ಸಾಗುತ್ತದೆ

ಚಿತ್ರಿಸಲಾಗುತ್ತಿರುವ stroke ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ composited page ಮೇಲೆ overlay ಆಗಿ render ಮಾಡಲಾಗುತ್ತದೆ. ಅಲ್ಲಿ erasure ಕೆಲಸ ಮಾಡಲಾರದು, ಏಕೆಂದರೆ ಆ overlay paper ಮತ್ತು ink ಎರಡರ ಮೇಲೂ ಇರುತ್ತದೆ, ಮತ್ತು destination-out paperನಲ್ಲೂ ರಂಧ್ರ ಮಾಡುತ್ತದೆ.

ಆದ್ದರಿಂದ eraser ತಕ್ಷಣವೇ strokesನಲ್ಲಿ ಬರೆಯುತ್ತದೆ, ಮತ್ತು ಹೊಸ samplesನ ಪ್ರತಿಯೊಂದು batch affected rectangleನ local replay ಅನ್ನು trigger ಮಾಡುತ್ತದೆ. Tile pipeline ಈಗಾಗಲೇ rectangle ಅನ್ನು clear ಮಾಡಿ ಅದನ್ನು intersect ಮಾಡುವ strokes ಅನ್ನು replay ಮಾಡುತ್ತದೆ; eraser ಅದೇ path ಅನ್ನು reuse ಮಾಡುತ್ತದೆ ಮತ್ತು drawingನ ಎರಡನೇ semantic ಅನ್ನು ಸೇರಿಸುವುದಿಲ್ಲ.

ಎರಡೂ ಎರೇಸರ್‌ಗಳು, ಪಕ್ಕಪಕ್ಕದಲ್ಲಿ

Toolbarನಲ್ಲಿ hidden mode ಇರುವ ಒಂದು button ಬದಲಿಗೆ ಎರಡು eraser buttons ಇವೆ. Partial eraser strokeನ ಒಂದು ಭಾಗವನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ. Stroke eraser contact ಆದಾಗ ಸಂಪೂರ್ಣ stroke ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ. ಅವುಗಳ radii ಬೇರೆ constants ಆಗಿದ್ದು, ಪ್ರಸ್ತುತ ಎರಡೂ 4 points.

ಸಂಪೂರ್ಣ stroke delete ಮಾಡಿದರೆ ಅದರ erase paths ಕೂಡ ಅದರ ಜೊತೆ ಹೋಗುತ್ತವೆ, ಏಕೆಂದರೆ ಅವು ಅದೇ strokeನ ಭಾಗ. Undo ಎರಡನ್ನೂ ಒಟ್ಟಿಗೆ ಮರಳಿಸುತ್ತದೆ. Erase paths saved fileನ ಭಾಗವೂ ಆಗಿವೆ, ಇತರ ಎಲ್ಲದರಂತೆ quantize ಮಾಡಲಾಗುತ್ತದೆ: radius ಮತ್ತು coordinates ಅನ್ನು pointನ tenths ಆಗಿ.

ಒಂದು limitation ಇನ್ನೂ ಉಳಿದಿದೆ. ಸಂಪೂರ್ಣವಾಗಿ erase ಆದ stroke data ಆಗಿ ಇನ್ನೂ ಅಸ್ತಿತ್ವದಲ್ಲಿರುತ್ತದೆ. ಅದು ಏನನ್ನೂ render ಮಾಡುವುದಿಲ್ಲ, ಆದರೆ lasso ಇನ್ನೂ ಅದನ್ನು select ಮಾಡಬಹುದು ಮತ್ತು stroke eraser ಅದನ್ನು delete ಮಾಡಬಹುದು; documentನಲ್ಲಿ ಅದು ಇನ್ನೂ ಜಾಗ ಹಿಡಿದಿರುತ್ತದೆ. ಸಂಪೂರ್ಣವಾಗಿ erased strokes ಅನ್ನು collect ಮಾಡಲು ನಾವು ಇನ್ನೂ ಬರೆಯದ coverage test ಬೇಕಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಈಗ ಅವು ಉಳಿಯುತ್ತವೆ.

ಬೇರೆ projectನ model ನಿಮ್ಮ projectನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದನ್ನು ನಿಲ್ಲಿಸಿದಾಗ, ವ್ಯತ್ಯಾಸ ಸಾಮಾನ್ಯವಾಗಿ ನೀವು copy ಮಾಡಿದ codeನಲ್ಲಿ ಇರುವುದಿಲ್ಲ. ಆ projectನಲ್ಲಿ ಇಲ್ಲದ featuresಗಳಲ್ಲೇ ಅದು ಇರುತ್ತದೆ.