ਦੋ ਇਰੇਜ਼ਰ, ਅਤੇ ਮਿਟਾਉਣਾ ਸਟ੍ਰੋਕ ਕੋਲ ਕਿਉਂ ਹੁੰਦਾ ਹੈ

ਜਦੋਂ ਲੋਕ ਨੋਟਬੁੱਕ ਵਿੱਚ ਕੁਝ ਮਿਟਾਉਂਦੇ ਹਨ, ਉਹ ਦੋ ਵੱਖਰੀਆਂ ਗੱਲਾਂ ਦਾ ਮਤਲਬ ਲੈ ਸਕਦੇ ਹਨ। ਕਈ ਵਾਰ ਕੋਈ ਨਿਸ਼ਾਨ ਗਲਤ ਹੁੰਦਾ ਹੈ ਅਤੇ ਪੂਰਾ ਨਿਸ਼ਾਨ ਹੀ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ: ਇੱਕ ਮਾਰਗਦਰਸ਼ਕ ਲਾਈਨ, ਕੱਟਿਆ ਹੋਇਆ ਸ਼ਬਦ, ਜਾਂ ਟਿਕੀ ਹੋਈ ਹਥੇਲੀ ਤੋਂ ਬਣਿਆ ਬੇਤਰਤੀਬ ਸਟ੍ਰੋਕ। ਕਈ ਵਾਰ ਨਿਸ਼ਾਨ ਦਾ ਸਿਰਫ਼ ਕੁਝ ਹਿੱਸਾ ਗਲਤ ਹੁੰਦਾ ਹੈ: ਕਿਸੇ ਅੱਖਰ ਦਾ ਅੱਧਾ ਹਿੱਸਾ, ਡਾਇਗ੍ਰਾਮ ਦੀ ਇੱਕ ਸ਼ਾਖ਼, ਜਾਂ ਵਾਕ ਤੋਂ ਅੱਗੇ ਨਿਕਲ ਗਈ ਹਾਈਲਾਈਟਰ ਸਵੀਪ ਦੀ ਪੂਛ। Lulucat Notes ਹੁਣ ਦੋਵੇਂ ਦਿੰਦਾ ਹੈ, ਦੋ ਵੱਖਰੇ ਟੂਲਾਂ ਵਜੋਂ।

ਅਸਲ ਔਖਾ ਡਿਜ਼ਾਈਨ ਸਵਾਲ ਇਹ ਹੈ ਕਿ ਮਿਟਾਉਣਾ ਰਹਿੰਦਾ ਕਿੱਥੇ ਹੈ।

ਸਟ੍ਰੋਕ ਇਰੇਜ਼ਰ ਪਹਿਲਾਂ ਆਇਆ

ਪਹਿਲਾ ਇਰੇਜ਼ਰ ਪੂਰੇ ਸਟ੍ਰੋਕ ਮਿਟਾਉਂਦਾ ਸੀ। ਇੱਕ touch ਹਰ ਸਟ੍ਰੋਕ ਨੂੰ ਜਾਂਚਦਾ ਹੈ: bounding boxes ਲਗਭਗ ਸਾਰੇ reject ਕਰ ਦਿੰਦੇ ਹਨ, ਅਤੇ ਬਚੇ ਹੋਏ ਸਟ੍ਰੋਕਾਂ ਲਈ ਇਰੇਜ਼ਰ radius ਅਤੇ ਉਸ segment ਉੱਤੇ interpolate ਕੀਤੇ stroke radius ਦੇ ਜੋੜ ਦੇ ਮੁਕਾਬਲੇ point-to-segment squared distance test ਹੁੰਦਾ ਹੈ। ਚੌੜਾਈ pressure ਨਾਲ ਬਦਲਦੀ ਹੈ, ਇਸ ਲਈ ਇੱਕੋ nominal width ਉਨ੍ਹਾਂ ਪਤਲੇ ਸਟ੍ਰੋਕਾਂ ਨੂੰ ਮਿਟਾ ਦੇਵੇਗੀ ਜਿਨ੍ਹਾਂ ਨੂੰ ਯੂਜ਼ਰ ਨੇ ਛੁਹਿਆ ਨਹੀਂ ਅਤੇ ਉਨ੍ਹਾਂ ਮੋਟੇ ਸਟ੍ਰੋਕਾਂ ਨੂੰ ਛੱਡ ਦੇਵੇਗੀ ਜਿਨ੍ਹਾਂ ਨੂੰ ਛੁਹਿਆ ਸੀ।

ਇੱਕ gesture ਇੱਕ undo entry ਵਿੱਚ ਮਿਲ ਜਾਂਦਾ ਹੈ, ਅਤੇ entry ਹਰ ਹਟਾਏ ਗਏ ਸਟ੍ਰੋਕ ਨੂੰ ਉਸ ਦੇ original index ਨਾਲ ਸੰਭਾਲਦੀ ਹੈ। Undo ਉਨ੍ਹਾਂ ਨੂੰ reverse order ਵਿੱਚ ਮੁੜ insert ਕਰਦਾ ਹੈ, ਇਸ ਲਈ stacking order ਬਿਲਕੁਲ ਪਹਿਲਾਂ ਵਰਗਾ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ।

ਇਹ ਇਰੇਜ਼ਰ ਤੇਜ਼, ਅਨੁਮਾਨਯੋਗ ਅਤੇ ਅੱਧਾ ਸ਼ਬਦ ਮਿਟਾਉਣ ਵਿੱਚ ਅਸਮਰੱਥ ਹੈ।

MaLiang ਇਰੇਜ਼ਰ ਨੂੰ ਬਰਸ਼ ਬਣਾ ਦਿੰਦਾ ਹੈ

MaLiang, ਉਹ MIT-licensed drawing framework ਜਿਸ ਤੋਂ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ highlighter stamp model ਲਿਆ ਸੀ, partial erasing ਦਾ ਜਵਾਬ 24 ਲਾਈਨਾਂ ਵਿੱਚ ਦਿੰਦਾ ਹੈ। ਇਸ ਦਾ Eraser ਇੱਕ Brush subclass ਹੈ, ਜੋ ਇੱਕੋ ਚੀਜ਼—blend options—ਨੂੰ override ਕਰਕੇ add ਦੀ ਥਾਂ subtract ਕਰਦਾ ਹੈ। ਇਰੇਜ਼ਰ ਸਟ੍ਰੋਕ ਹਰ ਹੋਰ ਸਟ੍ਰੋਕ ਵਾਂਗ ਉਸੇ list ਦਾ ਇੱਕ element ਹੈ। Undo ਉਹ element ਹਟਾਉਂਦਾ ਹੈ। ਕੋਈ ਮੌਜੂਦਾ ਸਟ੍ਰੋਕ modified ਨਹੀਂ ਹੁੰਦਾ, ਕਿਉਂਕਿ ਮਿਟਾਉਣਾ ਸਿਰਫ਼ list order ਵਿੱਚ replay ਦੌਰਾਨ ਹੁੰਦਾ ਹੈ।

ਅਸੀਂ ਉਹ ਮਾਡਲ ship ਕੀਤਾ, ਅਤੇ ਦੋ device sessions ਨੇ ਇਸ ਨੂੰ ਤੋੜ ਦਿੱਤਾ।

ਆਬਜੈਕਟ move ਨੇ ਗੁੰਮ ਮਾਲਕ ਸਾਹਮਣੇ ਲਿਆ ਦਿੱਤਾ

ਪਹਿਲੀ ਰਿਪੋਰਟ: lasso ਨਾਲ ਸਟ੍ਰੋਕ ਚੁਣੋ, ਉਨ੍ਹਾਂ ਨੂੰ drag ਕਰੋ, ਅਤੇ ਖਾਲੀ ਥਾਂ ਪਿੱਛੇ ਰਹਿ ਜਾਂਦੀ ਹੈ।

ਉਹੀ ਮਿਟਾਏ ਗਏ ਸਟ੍ਰੋਕ, ਸੱਜੇ ਪਾਸੇ ਹਿਲਾਏ ਹੋਏ। ਉੱਪਰ: ਇਰੇਜ਼ਰ ਆਪਣਾ ਵੱਖਰਾ element ਹੈ। ਹੇਠਾਂ: ਮਿਟਾਉਣਾ ਸਟ੍ਰੋਕ ਨਾਲ ਜੁੜਿਆ ਹੈ।

Selection ਨੇ ਇਸ ਨੂੰ ਹੋਰ ਖ਼ਰਾਬ ਕਰ ਦਿੱਤਾ। ਚੁਣੇ ਹੋਏ ਸਟ੍ਰੋਕ bitmap ਵਿੱਚੋਂ overlay ਵਿੱਚ lift ਹੋ ਜਾਂਦੇ ਹਨ, ਜਿੱਥੇ ਉਹ ਇਰੇਜ਼ਰ element ਤੋਂ ਬਿਨਾਂ ਸਿੱਧੇ draw ਹੁੰਦੇ ਹਨ। ਇਸ ਲਈ ਜਿਵੇਂ ਹੀ ਤੁਸੀਂ ਮਿਟਾਏ ਹੋਏ ਸਟ੍ਰੋਕ ਨੂੰ ਚੁਣਦੇ, ਉਹ ਮੁੜ ਪੂਰਾ ਦਿਖਾਈ ਦੇਣ ਲੱਗਦਾ।

ਦੂਜੀ ਰਿਪੋਰਟ: ਇਰੇਜ਼ਰ highlighter ਦੇ ਉੱਪਰ ਤੈਰਦਾ ਸੀ। ਸਾਡਾ renderer ਦੋ passes ਵਿੱਚ replay ਕਰਦਾ ਹੈ, ਪਹਿਲਾਂ highlighters ਅਤੇ ਫਿਰ pens, ਕਿਉਂਕਿ highlighter ink ਨੂੰ ink ਦੇ ਹੇਠਾਂ ਰਹਿਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੱਕ ਇਰੇਜ਼ਰ element ਨੂੰ ਦੋਵੇਂ passes ਵਿੱਚ ਹਿੱਸਾ ਲੈਣਾ ਪੈਂਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ ਇਹ ਦੋਵੇਂ ਕਿਸਮਾਂ ਨੂੰ ਮਿਟਾ ਨਹੀਂ ਸਕਦਾ। Pen pass ਵਿੱਚ ਹਿੱਸਾ ਲੈਣ ਦਾ ਮਤਲਬ ਹੈ ਹਰ highlighter ਦੇ draw ਹੋਣ ਤੋਂ ਬਾਅਦ ਚੱਲਣਾ, ਇਸ ਲਈ ਇਰੇਜ਼ਰ ਸਮੇਂ ਵਿੱਚ ਬਾਅਦ ਵਿੱਚ draw ਕੀਤੇ highlighter ਸਟ੍ਰੋਕਾਂ ਨੂੰ ਵੀ ਕੱਟ ਦਿੰਦਾ ਸੀ।

ਦੋਵੇਂ ਨਾਕਾਮੀਆਂ ਦਾ ਸਰੋਤ ਇੱਕੋ ਹੈ। MaLiang ਵਿੱਚ lasso, move ਜਾਂ brushes ਵਿਚਕਾਰ layer order ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਮਾਲਕ ਤੋਂ ਬਿਨਾਂ element ਉੱਥੇ ਕਾਫ਼ੀ ਹੈ। ਸਾਡੇ canvas ਵਿੱਚ ਇਹ ਤਿੰਨੇ ਹਨ, ਅਤੇ ਮਾਲਕ ਤੋਂ ਬਿਨਾਂ ਮਿਟਾਉਣ ਕੋਲ ਇਸ ਸਵਾਲ ਦਾ ਕੋਈ ਨਿਰਧਾਰਤ ਜਵਾਬ ਨਹੀਂ ਕਿ “ਜਦੋਂ ink ਹਿਲੇ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ” ਜਾਂ “ਇਹ ਕਿਹੜੀ layer ਉੱਤੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।”

ਸਟ੍ਰੋਕ ਦੀ ਮਲਕੀਅਤ ਵਾਲਾ ਮਿਟਾਉਣਾ

ਹੁਣ ਹਰ Stroke ਆਪਣੇ erase paths ਨਾਲ ਆਉਂਦਾ ਹੈ। ਇਰੇਜ਼ਰ ਜਾਂਚਦਾ ਹੈ ਕਿ ਉਹ ਕਿਹੜੇ ਸਟ੍ਰੋਕਾਂ ਨੂੰ ਛੁਹਿੰਦਾ ਹੈ ਅਤੇ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਨਾਲ canvas coordinates ਵਿੱਚ ਇੱਕ path ਜੋੜ ਦਿੰਦਾ ਹੈ। ਇੱਕ ਸਟ੍ਰੋਕ ਨੂੰ render ਕਰਨਾ ਉਸ ਦੀ ink ਅਤੇ ਉਸ ਦੇ ਆਪਣੇ erasures ਨੂੰ ਇੱਕ transparency layer ਦੇ ਅੰਦਰ ਖਿੱਚਦਾ ਹੈ:

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 ਉਹ ਇੱਕੋ ਸਟ੍ਰੋਕ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ operation ਕਾਗਜ਼, ਹੇਠਾਂ ਵਾਲੇ ਸਟ੍ਰੋਕਾਂ ਜਾਂ ਬਾਅਦ ਵਿੱਚ draw ਕੀਤੇ ਸਟ੍ਰੋਕਾਂ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚ ਸਕਦਾ। ਜਿਨ੍ਹਾਂ ਸਟ੍ਰੋਕਾਂ ਵਿੱਚ erasures ਨਹੀਂ ਹਨ, ਉਨ੍ਹਾਂ ਲਈ layer ਦੀ ਕੋਈ ਲਾਗਤ ਨਹੀਂ—ਅਤੇ ਅਜਿਹੇ ਸਟ੍ਰੋਕ ਲਗਭਗ ਸਾਰੇ ਹਨ: ਉਹ original path ਲੈਂਦੇ ਹਨ।

Ownership ਦੋਵੇਂ ਨਾਕਾਮੀਆਂ ਦਾ ਸਿੱਧਾ ਜਵਾਬ ਦਿੰਦੀ ਹੈ। Translation erase paths ਨੂੰ sample points ਦੇ ਨਾਲ ਹਿਲਾਉਂਦੀ ਹੈ, ਇਸ ਲਈ ਹਿਲਾਇਆ ਹੋਇਆ ਸਟ੍ਰੋਕ ਆਪਣੀਆਂ ਖਾਲੀ ਥਾਵਾਂ ਨਾਲ ਚੱਲਦਾ ਹੈ। Selection overlay ਉਹੀ stroke object draw ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਚੁਣਿਆ ਹੋਇਆ ਸਟ੍ਰੋਕ ਉਹੀ ਖਾਲੀ ਥਾਵਾਂ ਦਿਖਾਉਂਦਾ ਹੈ। Layer order ਹੁਣ ਮਾਇਨੇ ਨਹੀਂ ਰੱਖਦਾ, ਕਿਉਂਕਿ ਮਿਟਾਉਣਾ ਆਪਣੇ ਸਟ੍ਰੋਕ ਤੋਂ ਇਲਾਵਾ ਕਿਸੇ ਹੋਰ ਉੱਤੇ ਲਾਗੂ ਨਹੀਂ ਹੁੰਦਾ।

Undo gesture ਉੱਤੇ ਕੰਮ ਕਰਦਾ ਹੈ: ਇੱਕ entry ਉਸ gesture ਨਾਲ ਬਣੇ ਹਰ (stroke, path) pair ਦੀ ਸੂਚੀ ਰੱਖਦੀ ਹੈ, undo ਉਹ paths ਹਟਾਉਂਦਾ ਹੈ ਅਤੇ redo ਉਨ੍ਹਾਂ ਨੂੰ ਮੁੜ append ਕਰਦਾ ਹੈ। ਇਰੇਜ਼ਰ ਦੇ ਹੇਠਾਂ ਵਾਲੀ ink ਕਦੇ edit ਨਹੀਂ ਹੁੰਦੀ, ਇਸ ਲਈ ਕਿਸੇ ਚੀਜ਼ ਨੂੰ reconstruct ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਪੈਂਦੀ।

Live feedback tile bitmap ਰਾਹੀਂ ਆਉਂਦੀ ਹੈ

ਜੋ ਸਟ੍ਰੋਕ draw ਹੋ ਰਿਹਾ ਹੁੰਦਾ ਹੈ, ਉਹ ਆਮ ਤੌਰ ਉੱਤੇ composited page ਦੇ ਉੱਪਰ ਇੱਕ overlay ਵਜੋਂ render ਹੁੰਦਾ ਹੈ। ਉੱਥੇ erasure ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਦੀ, ਕਿਉਂਕਿ ਉਹ overlay paper ਦੇ ਨਾਲ-ਨਾਲ ink ਦੇ ਉੱਪਰ ਵੀ ਬੈਠੀ ਹੈ ਅਤੇ destination-out paper ਵਿੱਚੋਂ ਵੀ ਛੇਦ ਕਰ ਦੇਵੇਗਾ।

ਇਸ ਲਈ ਇਰੇਜ਼ਰ ਤੁਰੰਤ ਸਟ੍ਰੋਕਾਂ ਵਿੱਚ ਲਿਖਦਾ ਹੈ, ਅਤੇ ਨਵੀਆਂ samples ਦੇ ਹਰ batch ਨਾਲ ਸਿਰਫ਼ ਪ੍ਰਭਾਵਿਤ rectangle ਦਾ local replay ਹੁੰਦਾ ਹੈ। Tile pipeline ਪਹਿਲਾਂ ਹੀ ਇੱਕ rectangle ਨੂੰ clear ਕਰਕੇ ਉਸ ਵਿੱਚ intersect ਕਰਨ ਵਾਲੇ ਸਟ੍ਰੋਕਾਂ ਨੂੰ replay ਕਰਦੀ ਹੈ; ਇਰੇਜ਼ਰ ਉਸੇ path ਨੂੰ ਮੁੜ ਵਰਤਦਾ ਹੈ ਅਤੇ ਕੋਈ ਦੂਜਾ drawing semantic ਨਹੀਂ ਜੋੜਦਾ।

ਦੋਵੇਂ ਇਰੇਜ਼ਰ, ਨਾਲ-ਨਾਲ

Toolbar ਵਿੱਚ ਇੱਕ hidden mode ਵਾਲੇ ਇੱਕ button ਦੀ ਥਾਂ ਦੋ eraser buttons ਹਨ। Partial eraser ਸਟ੍ਰੋਕ ਦਾ ਕੁਝ ਹਿੱਸਾ ਮਿਟਾਉਂਦਾ ਹੈ। Stroke eraser ਸੰਪਰਕ ਹੋਣ ਉੱਤੇ ਪੂਰੇ ਸਟ੍ਰੋਕ ਹਟਾਉਂਦਾ ਹੈ। ਉਨ੍ਹਾਂ ਦੇ radii ਵੱਖਰੇ constants ਹਨ, ਅਤੇ ਦੋਵੇਂ ਇਸ ਵੇਲੇ 4 points ਹਨ।

ਪੂਰਾ ਸਟ੍ਰੋਕ ਮਿਟਾਉਣ ਨਾਲ ਉਸ ਦੇ erase paths ਵੀ ਨਾਲ ਚਲੇ ਜਾਂਦੇ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਉਸੇ ਸਟ੍ਰੋਕ ਦਾ ਹਿੱਸਾ ਹਨ, ਅਤੇ undo ਦੋਵੇਂ ਨੂੰ ਇਕੱਠੇ ਵਾਪਸ ਲਿਆਉਂਦਾ ਹੈ। Erase paths saved file ਦਾ ਵੀ ਹਿੱਸਾ ਹਨ ਅਤੇ ਬਾਕੀ ਹਰ ਚੀਜ਼ ਵਾਂਗ quantized ਹਨ: radius ਅਤੇ coordinates point ਦੇ ਦਸਵੇਂ ਹਿੱਸਿਆਂ ਵਜੋਂ।

ਇੱਕ ਸੀਮਾ ਹਾਲੇ ਵੀ ਹੈ। ਪੂਰੀ ਤਰ੍ਹਾਂ ਮਿਟਾਇਆ ਗਿਆ ਸਟ੍ਰੋਕ data ਵਜੋਂ ਮੌਜੂਦ ਰਹਿੰਦਾ ਹੈ। ਉਹ ਕੁਝ render ਨਹੀਂ ਹੁੰਦਾ, ਪਰ lasso ਹਾਲੇ ਵੀ ਉਸ ਨੂੰ select ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ stroke eraser ਉਸ ਨੂੰ delete ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਉਹ document ਵਿੱਚ ਥਾਂ ਵੀ ਘੇਰਦਾ ਹੈ। ਪੂਰੀ ਤਰ੍ਹਾਂ ਮਿਟਾਏ ਸਟ੍ਰੋਕ ਇਕੱਠੇ ਕਰਨ ਲਈ coverage test ਚਾਹੀਦਾ ਹੈ, ਜੋ ਅਸੀਂ ਹਾਲੇ ਨਹੀਂ ਲਿਖਿਆ, ਇਸ ਲਈ ਫਿਲਹਾਲ ਉਹ ਰਹਿੰਦੇ ਹਨ।

ਜਦੋਂ ਕਿਸੇ ਹੋਰ project ਤੋਂ ਲਿਆ ਮਾਡਲ ਤੁਹਾਡੇ project ਵਿੱਚ ਕੰਮ ਕਰਨਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਫ਼ਰਕ ਆਮ ਤੌਰ ਉੱਤੇ ਉਸ code ਵਿੱਚ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਤੁਸੀਂ copy ਕੀਤਾ ਹੈ। ਫ਼ਰਕ ਉਨ੍ਹਾਂ features ਵਿੱਚ ਹੁੰਦਾ ਹੈ ਜੋ ਉਸ project ਵਿੱਚ ਹਨ ਹੀ ਨਹੀਂ।