Release v0.6.24: smart shapes, rotation and canvas zoom

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.24)
-project(KSwitcher VERSION 0.6.23 LANGUAGES CXX RC)
+project(KSwitcher VERSION 0.6.24 LANGUAGES CXX RC)
 if(NOT WIN32)
   message(FATAL_ERROR "KSwitcher uses native Windows APIs")
 endif()

README.md

@@ -111,10 +111,10 @@ change its diameter. Wheel up increases the size; wheel down decreases it. These
 and update linked arrows. **Ctrl+D** clones the selected object with a small offset. A cloned number
 gets the smallest available positive number, just like a newly placed number: gaps left by deletion
 are filled first, without renumbering existing objects. A cloned arrow keeps its style but starts without endpoint links.
-Arrow and line endpoints can attach to numbered markers, rectangles, circles, ellipses, text blocks,
+Arrow and line endpoints can attach to numbered markers, rectangles, circles, ellipses, triangles, trapezoids, text blocks,
 and other arrows or strokes. In Arrow or Straight line mode, hold **Ctrl** and drag from one object
 to another to draw over them and automatically attach both endpoints. Without Ctrl, existing objects
-can still be selected and edited as before. With Pointer, drag an existing endpoint onto a target to attach it. Attached endpoints follow movement and resizing; text attachments
+can still be selected and edited as before. With Pointer, drag an existing endpoint onto a target to attach it. Attached endpoints follow movement and resizing; shape and text attachments
 also follow rotation. Arrow-to-arrow attachments retain their relative position along the target line.
 Clicking a connector or adding/editing its caption preserves its links. Moving the whole connector
 intentionally detaches its endpoints; moving one endpoint detaches only that end. Deleting a target
@@ -162,7 +162,34 @@ resize; circles keep equal width and height. Move shapes by their outlines, adju
 the mouse wheel or side handle, recolor, clone with Ctrl+D, and undo/redo as with other objects.
 Hold Ctrl to start drawing over an existing object. Line style applies to outlines; Ends is disabled
 for shapes.
+**Canvas zoom:** use **Ctrl++ / Ctrl+-** (including numpad keys) or **Ctrl+mouse wheel**.
+Each step changes the view by 25%; the wheel zooms around the cursor, keyboard shortcuts around
+the viewport center. **Ctrl+0** restores the initial fit. Drag with the **middle mouse button**
+to pan an enlarged image. Zoom ranges from 0.1× to 16× the initial fit; the status bar shows the
+actual image scale. Zoom and pan do not change annotations, export resolution or undo history.
+The wheel without Ctrl still adjusts the object under the cursor.
+
 **Freehand line (F)** draws an opaque curve by following the mouse. The curve is one object:
+after mouse release, light smoothing reduces jitter. Confidently recognized closed outlines become
+rectangles, circles, ellipses, triangles or trapezoids (including tilted outlines), stored as shape objects.
+Drag either bounding-box corner handle to resize the entire recognized outline; circles keep equal
+width and height. Shapes can also be moved, recolored and cloned.
+Every shape has a round rotation handle above its outline. Drag it to rotate around the center;
+hold **Shift** for 15-degree steps. The handle works for toolbar shapes and recognized shapes,
+including triangles. Resize handles and attached connectors follow the rotation; Ctrl+Z/Ctrl+Y
+undo and redo it. The square handle still controls outline thickness.
+**Triangle (G)** is also available directly on the toolbar: drag to create a triangle.
+Both drawn and recognized triangles have three independent vertex handles instead of bounding-box
+resize handles. Drag any vertex to reshape the triangle while keeping the other two fixed, even
+after rotation. Vertex edits support undo/redo, and the rotation and thickness handles remain available.
+**Trapezoid (B)** on the toolbar creates a trapezoid with parallel bases. Pencil recognition also
+fits nearly parallel, unequal bases into a clean trapezoid. Trapezoids support bounding-box resizing,
+rotation, styling and undo/redo; Ctrl+Z after recognition restores the original pencil stroke.
+Oval fitting tolerates uneven contours and small closing gaps or overlaps; broad open arcs and
+repeated loops remain freehand strokes.
+Press **Ctrl+Z** once to restore the original stroke, again to remove it; **Ctrl+Y** reapplies the improvement.
+Small strokes, strokes linked to other objects, and any stroke drawn partly with Shift are left unchanged.
+Ambiguous shapes are only smoothed. To edit the resulting curve,
 move it, change its color or thickness, clone it, or drag its endpoints. Hold Ctrl to start a new
 stroke over an existing object. Hold **Shift** while drawing to constrain the current segment
 to a horizontal, vertical or 45-degree diagonal line; release Shift to resume freehand drawing in the same stroke.

Release/README.md

@@ -1,19 +1,20 @@
 # Latest Windows release
 
-## v0.6.23 — 2026-11-01
+## v0.6.24 — 2026-11-01
 
 ## Changes
-- Add Ukrainian `поточні` to the bundled dictionary: `Gjnjxys ` and `Поточны ` can become `Поточні ` with Ukrainian enabled. Supplemental rank 50001 is included by the default unlimited frequency setting.
-- Use paced selection in Chrome and Edge, as already used for Teams/WebView, to reduce incomplete selections during recent-text conversion, repeat conversion and Undo. Full verification remains mandatory.
-- Save annotated screenshots as full-resolution PNG with **Save… / Ctrl+S**. The first save asks for a destination; later saves update it. **Ctrl+Shift+S** opens Save As. Saving keeps the editor open and does not change the clipboard. Closing warns about changes not saved or copied.
+- Smooth pencil strokes and recognize rectangles, circles, ellipses, triangles and trapezoids, including tilted contours. Ctrl+Z restores the original stroke; Ctrl+Y reapplies the improvement.
+- Recognized outlines become editable shapes. Add Triangle (G) and Trapezoid (B) toolbar tools; triangles have three independently draggable vertices.
+- Rotate all shapes with their round handle, with Shift snapping to 15-degree steps. Resizing, cloning, connector attachments and PNG export follow shape rotation.
+- Zoom with Ctrl++ / Ctrl+- or Ctrl+mouse wheel, reset with Ctrl+0 and pan with middle-button dragging. Zooming does not change image resolution or undo history.
 
 ## Validation
-423 native regressions, 473 input/UI checks, shared wheel handling, screenshot editor UI, PNG save regressions, notification registration, 48 updater checks and updater progress checks passed.
+423 native regressions, 473 input/UI checks, shared wheel handling, screenshot editor and shape/zoom regressions, PNG save regressions, notification registration, 48 updater checks and updater progress checks passed.
 
 ## Limitations
-The reported Chrome editor failure has not yet been verified live after the selection change. Existing clipboard/accessibility restrictions and paste readback limitations remain. Automatic correction runs after Space and requires a dictionary match.
+Shape recognition is heuristic: ambiguous outlines may remain smoothed strokes or require Ctrl+Z to restore the original. Small, linked and Shift-constrained pencil strokes are not automatically improved. Triangle vertices are edited independently; trapezoids use bounding-box resize handles. Canvas zoom is limited to 0.1×–16× the initial fit. PNG exports are flattened images, not editable projects.
 
-**Dictionary upgrade:** the updater preserves existing dictionaries, so an older installation may not receive the new word automatically. Add `поточні` under **Settings → Auto-correction options → My dictionary → Ukrainian**, then click **OK → Save**. Personal words work at any frequency rank limit. Back up custom dictionary files before replacing them manually.
+Existing browser-selection verification and clipboard/accessibility limitations remain unchanged. The bundled Ukrainian dictionary includes `поточні`; updates preserve existing dictionaries. If missing, add it under Settings → Auto-correction options → My dictionary → Ukrainian, then OK → Save.
 
 **Upgrade:** choose Update in the tray menu. Legacy v0.3.0–v0.4.1 clients first receive the v0.4.2 compatibility bridge, then the current full release. v0.2.3 and earlier require manual installation.
 For manual installation, exit KSwitcher, close screenshot editors and extract the entire ZIP into its installation folder. Keep personal `data/` and customized dictionaries.

Release/SHA256SUMS.txt

@@ -1 +1 @@
-414604b295912ad466c1a6c6b6ff85b032b9e4480bf115c249885cef60817475  KSwitcher-win-x64.zip
+5976c1363e4342830f503cba6d17b3ec1386741f636932117d9b08f55004af92  KSwitcher-win-x64.zip

resources/app.rc

@@ -9,8 +9,8 @@ IDC_SCREENSHOT_PENCIL CURSOR "icons/lucide/pencil.cur"
 1 RT_MANIFEST "app.manifest"
 201 RCDATA "update.ps1"
 1 VERSIONINFO
- FILEVERSION 0,6,23,0
- PRODUCTVERSION 0,6,23,0
+ FILEVERSION 0,6,24,0
+ PRODUCTVERSION 0,6,24,0
  FILEOS VOS_NT_WINDOWS32
  FILETYPE VFT_APP
 BEGIN
@@ -20,7 +20,7 @@ BEGIN
   BEGIN
    VALUE "FileDescription", "KSwitcher — native keyboard and clipboard utility"
    VALUE "ProductName", "KSwitcher"
-   VALUE "FileVersion", "0.6.23"
+   VALUE "FileVersion", "0.6.24"
   END
  END
  BLOCK "VarFileInfo"

src/screenshot.cpp

@@ -1,4 +1,5 @@
 #include "screenshot.h"
+#include "stroke_improvement.h"
 #include "ocr.h"
 #include "../resources/resource.h"
 #include <algorithm>
@@ -53,7 +54,7 @@ bool confirmScreenshotClose(HWND owner)
     // If Windows cannot display the confirmation, keep the screenshot open.
     return SUCCEEDED(result) && button==IDYES;
 }
-constexpr int ToolIds[]{27,10,11,22,23,24,25,21,19,26,20,12,18,13};
+constexpr int ToolIds[]{27,10,11,22,23,24,25,36,37,21,19,26,20,12,18,13};
 struct Surface
 {
     HDC dc = CreateCompatibleDC(nullptr);
@@ -123,7 +124,7 @@ bool chooseTextFont(HWND owner,Mark &m)
     m.fontWeight=font.lfWeight; m.fontItalic=font.lfItalic!=0;
     return true;
 }
-constexpr int CursorTools[]{10,11,22,23,24,25,19};
+constexpr int CursorTools[]{10,11,22,23,24,25,36,37,19};
 HCURSOR makeToolCursor(int tool,int size)
 {
     // Monochrome AND/XOR cursor: white outline keeps the glyph visible on dark images.
@@ -148,6 +149,8 @@ HCURSOR makeToolCursor(int tool,int size)
         case 23: Rectangle(dc,x(17),y(18),x(30),y(29)); break;
         case 24: Ellipse(dc,x(17),y(17),x(30),y(30)); break;
         case 25: Ellipse(dc,x(16),y(20),x(31),y(28)); break;
+        case 36: { POINT p[]{{x(23),y(17)},{x(31),y(30)},{x(16),y(30)},{x(23),y(17)}}; Polyline(dc,p,4); break; }
+        case 37: { POINT p[]{{x(20),y(18)},{x(27),y(18)},{x(31),y(30)},{x(16),y(30)},{x(20),y(18)}}; Polyline(dc,p,5); break; }
         case 19:
             line(18,25,25,18); line(25,18,29,22); line(29,22,22,29);
             line(22,29,18,25); line(18,25,17,30); line(17,30,22,29); break;
@@ -179,12 +182,18 @@ struct Capture
     COLORREF customColors[16]{};
     Mark stroke{};
     bool strokeConstrained{};
+    bool strokeUsedConstraint{};
     size_t strokeAnchor{};
     int strokeAxis{}; // 0 = not chosen, 1 = horizontal, 2 = vertical, 3/4 = diagonals.
     bool strokeAxisSettled{};
     std::vector<POINT> strokeMotion;
     POINT start{}, end{};
     RECT selection{}, view{};
+    RECT canvas{};
+    double zoom=1,panX=0,panY=0;
+    bool panning=false;
+    POINT panOrigin{};
+    int zoomWheelDelta=0;
     std::vector<Mark> marks;
     ScreenshotHistory history;
     HWND editor{}, inlineText{};
@@ -243,9 +252,10 @@ void updateStatus(Capture &c)
         if(c.hoveredTool==28) text=L"Save (Ctrl+S) | Save As... (Ctrl+Shift+S)";
     }
     else if(c.inlineText) text=L"Text: Enter = new line | Ctrl+Enter = apply | Esc = cancel";
-    else if(part==MarkPart::Rotation) text=L"Drag to rotate text | Hold Shift for 15-degree steps";
+    else if(part==MarkPart::Rotation) text=L"Drag to rotate | Hold Shift for 15-degree steps";
     else if(part==MarkPart::Thickness) text=L"Drag to change thickness | Mouse wheel over object = size";
     else if(part==MarkPart::Radius) text=L"Drag to resize the number | Mouse wheel = diameter";
+    else if(part>=MarkPart::Vertex0 && part<=MarkPart::Vertex2) text=L"Drag triangle vertex | Other vertices stay fixed";
     else if(part==MarkPart::Start || part==MarkPart::End) text=L"Drag handle to resize | Endpoints can snap to objects and other arrows";
     else if(c.selected>=0) {
         const auto &m=c.marks[c.selected];
@@ -257,9 +267,11 @@ void updateStatus(Capture &c)
     else if(c.pointer) text=L"Pointer (V): select and edit objects | Drag handles = geometry or thickness | Empty space clears selection";
     else if(c.textTool) text=L"Text (T): click the image to type | Double-click existing text to edit";
     else if(c.highlight) text=L"Highlight (H): drag to paint | Ctrl+drag = paint over an object | V = pointer";
-    else if(c.freehand) text=L"Freehand (F): Shift = 45-degree steps; move >50 px off line to turn | Ctrl = draw over objects";
+    else if(c.freehand) text=L"Freehand (F): auto-smooth / shapes; Ctrl+Z restores original | Shift = 45-degree steps | Ctrl = draw over objects";
     else if(c.arrow) text=L"Drag to draw | Ctrl+drag over objects = linked connector | V = pointer";
     else text=L"Number (N): click to add | V = select and edit | Ctrl+C = copy screenshot";
+    text=L"Zoom: "+std::to_wstring(int(std::lround(100.0*(c.view.right-c.view.left)/c.image->width)))+
+         L"% (Ctrl +/- / wheel; Ctrl+0: fit; middle drag: pan) | "+text;
     if(text!=c.statusText) {
         c.statusText=std::move(text);
         SendMessageW(status,SB_SETTEXTW,0,(LPARAM)c.statusText.c_str());
@@ -299,6 +311,12 @@ void positionInlineText(Capture &c)
     int width=std::min(std::max(120,MulDiv(bounds.right-bounds.left,viewWidth,c.image->width)+24),std::max(32,int(client.right)-x));
     int height=std::min(std::max(40,MulDiv(bounds.bottom-bounds.top,viewWidth,c.image->width)+24),std::max(32,int(client.bottom)-c.statusHeight-y));
     SetWindowPos(c.inlineText,nullptr,x-2,y-2,width,height,SWP_NOZORDER|SWP_NOACTIVATE);
+    RECT editorBounds{x-2,y-2,x-2+width,y-2+height},visible{};
+    IntersectRect(&visible,&editorBounds,&c.canvas);
+    auto clip=IsRectEmpty(&visible)?CreateRectRgn(0,0,0,0):
+        CreateRectRgn(visible.left-editorBounds.left,visible.top-editorBounds.top,
+                      visible.right-editorBounds.left,visible.bottom-editorBounds.top);
+    if(!SetWindowRgn(c.inlineText,clip,TRUE)) DeleteObject(clip);
 }
 Mark textStyleDefaults(const Mark &source)
 {
@@ -339,6 +357,10 @@ void finishInlineText(HWND w,Capture &c,bool commit)
 }
 LRESULT CALLBACK inlineTextProc(HWND w,UINT msg,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR)
 {
+    if(msg==WM_KEYDOWN && (GetKeyState(VK_CONTROL)&0x8000) &&
+       (wp==VK_OEM_PLUS || wp==VK_ADD || wp==VK_OEM_MINUS || wp==VK_SUBTRACT || wp=='0' || wp==VK_NUMPAD0)) {
+        SendMessageW(GetParent(w),msg,wp,lp); return 0;
+    }
     if(msg==WM_KEYDOWN && wp=='S' && (GetKeyState(VK_CONTROL)&0x8000)) {
         PostMessageW(GetParent(w),WM_COMMAND,(GetKeyState(VK_SHIFT)&0x8000)?29:28,0); return 0;
     }
@@ -372,9 +394,47 @@ void beginMarkText(HWND w,Capture &c,int index)
         beginInlineText(w,c,label,index); c.editingLabel=true;
     }
 }
+POINT rotateShapePoint(const Mark &m,POINT p,double direction=1)
+{
+    if(m.shape==ScreenshotShape::None || m.rotation==0) return p;
+    double cx=(m.from.x+m.to.x)/2.0,cy=(m.from.y+m.to.y)/2.0;
+    double a=direction*m.rotation*3.141592653589793/180,cs=std::cos(a),sn=std::sin(a);
+    return {LONG(std::lround(cx+(p.x-cx)*cs-(p.y-cy)*sn)),
+            LONG(std::lround(cy+(p.x-cx)*sn+(p.y-cy)*cs))};
+}
+std::vector<POINT> shapeOutline(const Mark &m)
+{
+    auto points=m.points;
+    if(points.empty()) {
+        auto r=region(m.from,m.to);
+        if(m.shape==ScreenshotShape::Rectangle)
+            points={{r.left,r.top},{r.right,r.top},{r.right,r.bottom},{r.left,r.bottom},{r.left,r.top}};
+        else if(m.shape==ScreenshotShape::Triangle)
+            points={{(r.left+r.right)/2,r.top},{r.right,r.bottom},{r.left,r.bottom},{(r.left+r.right)/2,r.top}};
+        else if(m.shape==ScreenshotShape::Trapezoid)
+            points={{r.left+(r.right-r.left)/4,r.top},{r.right-(r.right-r.left)/4,r.top},
+                    {r.right,r.bottom},{r.left,r.bottom},{r.left+(r.right-r.left)/4,r.top}};
+        else {
+            for(int i=0;i<180;++i) {
+                double a=i*2*3.141592653589793/180;
+                points.push_back({LONG(std::lround((r.left+r.right)/2.0+(r.right-r.left)/2.0*std::cos(a))),
+                                  LONG(std::lround((r.top+r.bottom)/2.0+(r.bottom-r.top)/2.0*std::sin(a)))});
+            }
+            points.push_back(points.front());
+        }
+    }
+    for(auto &p:points) p=rotateShapePoint(m,p);
+    return points;
+}
 RECT markBounds(const Mark &m)
 {
     if(m.isText()) return screenshotTextBounds(m);
+    if(m.shape!=ScreenshotShape::None && m.rotation!=0) {
+        auto points=shapeOutline(m); RECT r{points[0].x,points[0].y,points[0].x,points[0].y};
+        for(auto p:points) { r.left=std::min(r.left,p.x); r.right=std::max(r.right,p.x);
+                            r.top=std::min(r.top,p.y); r.bottom=std::max(r.bottom,p.y); }
+        return r;
+    }
     RECT r=region(m.from,m.to);
     for(auto p:m.points) {
         r.left=std::min(r.left,p.x); r.top=std::min(r.top,p.y);
@@ -386,7 +446,7 @@ std::pair<POINT,POINT> thicknessSegment(const Mark &m)
 {
     if(m.shape!=ScreenshotShape::None) {
         auto r=region(m.from,m.to);
-        return {{r.right,r.top},{r.left,r.top}};
+        return {rotateShapePoint(m,{r.right,r.top}),rotateShapePoint(m,{r.left,r.top})};
     }
     if(m.freehand && m.points.size()>1) {
         size_t index=(m.points.size()-1)/2;
@@ -490,7 +550,10 @@ void drawMarks(HDC dc, const std::vector<Mark> &marks, const Mark *preview = nul
             if(m.shape!=ScreenshotShape::None) {
                 auto hollow=SelectObject(dc,GetStockObject(HOLLOW_BRUSH));
                 auto r=region(m.from,m.to);
-                if(m.shape==ScreenshotShape::Rectangle) Rectangle(dc,r.left,r.top,r.right+1,r.bottom+1);
+                if(!m.points.empty() || m.rotation!=0 || m.shape==ScreenshotShape::Triangle || m.shape==ScreenshotShape::Trapezoid) {
+                    auto points=shapeOutline(m); Polyline(dc,points.data(),int(points.size()));
+                }
+                else if(m.shape==ScreenshotShape::Rectangle) Rectangle(dc,r.left,r.top,r.right+1,r.bottom+1);
                 else Ellipse(dc,r.left,r.top,r.right+1,r.bottom+1);
                 SelectObject(dc,hollow);
                 SelectObject(dc,previousPen); DeleteObject(arrowPen);
@@ -605,7 +668,7 @@ void layout(HWND w, Capture &c)
     RECT statusRect{}; GetWindowRect(status,&statusRect);
     c.statusHeight=statusRect.bottom-statusRect.top;
     r.bottom-=c.statusHeight;
-    const int positions[]{8,44,80,116,152,188,224,260,296,332,368,416,452,500};
+    const int positions[]{8,44,80,116,152,188,224,260,296,332,368,404,440,488,524,572};
     static_assert(std::size(positions)==std::size(ToolIds));
     for (size_t i = 0; i < std::size(ToolIds); ++i)
     {
@@ -614,7 +677,7 @@ void layout(HWND w, Capture &c)
                    MulDiv(32,dpi,96),MulDiv(32,dpi,96),TRUE);
     }
     SendDlgItemMessageW(w,28,WM_SETFONT,(WPARAM)c.font,TRUE);
-    MoveWindow(GetDlgItem(w,28),MulDiv(540,dpi,96),MulDiv(6,dpi,96),
+    MoveWindow(GetDlgItem(w,28),MulDiv(612,dpi,96),MulDiv(6,dpi,96),
                MulDiv(78,dpi,96),MulDiv(32,dpi,96),TRUE);
     c.panelHeight=c.unit+MulDiv(40,dpi,96);
     for(int id:{30,31,32,33,34,35}) SendDlgItemMessageW(w,id,WM_SETFONT,(WPARAM)c.font,TRUE);
@@ -625,13 +688,35 @@ void layout(HWND w, Capture &c)
     MoveWindow(GetDlgItem(w,34),MulDiv(480,dpi,96),c.unit+MulDiv(2,dpi,96),MulDiv(28,dpi,96),MulDiv(28,dpi,96),TRUE);
     MoveWindow(GetDlgItem(w,35),MulDiv(516,dpi,96),c.unit+MulDiv(2,dpi,96),MulDiv(28,dpi,96),MulDiv(28,dpi,96),TRUE);
     syncLineOptions(w,c);
-    double ratio = std::min({1.0, double(std::max(1L,r.right-16))/c.image->width,
+    c.canvas={0,c.panelHeight,r.right,std::max(LONG(c.panelHeight+1),r.bottom)};
+    double ratio = c.zoom*std::min({1.0, double(std::max(1L,r.right-16))/c.image->width,
                                   double(std::max(1L,r.bottom-c.panelHeight-16))/c.image->height});
-    int width = int(c.image->width*ratio), height = int(c.image->height*ratio);
-    c.view = {(r.right-width)/2, c.panelHeight+(r.bottom-c.panelHeight-height)/2,
-              (r.right+width)/2, c.panelHeight+(r.bottom-c.panelHeight+height)/2};
+    int width = std::max(1,int(std::lround(c.image->width*ratio))), height = std::max(1,int(std::lround(c.image->height*ratio)));
+    double maxX=std::max(0.0,(width-double(c.canvas.right-c.canvas.left))/2);
+    double maxY=std::max(0.0,(height-double(c.canvas.bottom-c.canvas.top))/2);
+    c.panX=std::clamp(c.panX,-maxX,maxX); c.panY=std::clamp(c.panY,-maxY,maxY);
+    LONG x=LONG(std::lround((r.right-width)/2.0+c.panX));
+    LONG y=LONG(std::lround(c.panelHeight+(r.bottom-c.panelHeight-height)/2.0+c.panY));
+    c.view = {x,y,x+width,y+height};
     InvalidateRect(w, nullptr, FALSE);
 }
+void zoomCanvas(HWND w,Capture &c,double factor,POINT anchor,bool reset=false)
+{
+    if(!c.editing || c.dragging || c.panning) return;
+    double u=double(anchor.x-c.view.left)/std::max(1L,c.view.right-c.view.left);
+    double v=double(anchor.y-c.view.top)/std::max(1L,c.view.bottom-c.view.top);
+    double next=reset?1.0:std::clamp(c.zoom*factor,.1,16.0);
+    if(next==c.zoom && !reset) return;
+    c.zoom=next;
+    if(reset) c.panX=c.panY=0;
+    layout(w,c);
+    if(!reset) {
+        c.panX+=anchor.x-(c.view.left+u*(c.view.right-c.view.left));
+        c.panY+=anchor.y-(c.view.top+v*(c.view.bottom-c.view.top));
+        layout(w,c);
+    }
+    positionInlineText(c); updateStatus(c); InvalidateRect(w,nullptr,FALSE);
+}
 POINT imagePoint(Capture &c, POINT p, bool clamp = true)
 {
     POINT result{MulDiv(p.x-c.view.left,c.image->width,std::max(1L,c.view.right-c.view.left)),
@@ -659,6 +744,10 @@ std::pair<int,MarkPart> markAt(Capture &c, POINT p)
     if(c.selected>=0)
     {
         const auto &m=c.marks[c.selected];
+        if(m.shape!=ScreenshotShape::None) {
+            auto grip=screenshotShapeRotationHandle(m,double(c.unit)*c.image->width/std::max(1L,c.view.right-c.view.left));
+            if(std::hypot(double(p.x-grip.x),double(p.y-grip.y))<=tolerance) return {c.selected,MarkPart::Rotation};
+        }
         if(m.isText() || (m.isLine() && !m.label.empty())) {
             auto text=m.isText()?m:screenshotArrowLabel(m);
             auto grip=screenshotTextRotationHandle(text,double(c.unit*0.6)*c.image->width/std::max(1L,c.view.right-c.view.left));
@@ -682,7 +771,7 @@ HCURSOR toolCursor(const Capture &c)
     if(c.pointer) return LoadCursorW(nullptr,IDC_ARROW);
     if(c.textTool) return LoadCursorW(nullptr,IDC_IBEAM);
     if(c.freehand && c.pencilCursor) return c.pencilCursor;
-    int tool=c.highlight?19:c.straight?22:c.shape!=ScreenshotShape::None?22+int(c.shape):c.arrow?11:10;
+    int tool=c.highlight?19:c.straight?22:c.shape==ScreenshotShape::Trapezoid?37:c.shape==ScreenshotShape::Triangle?36:c.shape!=ScreenshotShape::None?22+int(c.shape):c.arrow?11:10;
     for(size_t i=0;i<std::size(CursorTools);++i)
         if(CursorTools[i]==tool && c.drawingCursors[i]) return c.drawingCursors[i];
     return LoadCursorW(nullptr,IDC_CROSS);
@@ -693,6 +782,7 @@ HCURSOR actionCursor(const Capture &c,std::pair<int,MarkPart> hit,bool inside)
     LPCWSTR cursor=nullptr;
     if(hit.second==MarkPart::Body || hit.second==MarkPart::Label) cursor=IDC_SIZEALL;
     else if(hit.second==MarkPart::Rotation) cursor=IDC_HAND;
+    else if(hit.second>=MarkPart::Vertex0 && hit.second<=MarkPart::Vertex2) cursor=IDC_SIZEALL;
     else if(hit.second==MarkPart::Radius) cursor=IDC_SIZEWE;
     else if(hit.second==MarkPart::Start || hit.second==MarkPart::End || hit.second==MarkPart::Thickness) {
         const auto &mark=c.marks[hit.first];
@@ -708,7 +798,7 @@ HCURSOR actionCursor(const Capture &c,std::pair<int,MarkPart> hit,bool inside)
 void captureCursor(HWND w, Capture &c)
 {
     POINT p; GetCursorPos(&p); ScreenToClient(w,&p);
-    bool inside=PtInRect(&c.view,p)!=FALSE;
+    bool inside=PtInRect(&c.view,p) && PtInRect(&c.canvas,p);
     auto hit=c.editing?(c.dragging?std::pair{c.selected,c.part}:markAt(c,imagePoint(c,p,false))):std::pair{-1,MarkPart::None};
     if(!c.dragging && !inside && hit.second!=MarkPart::Thickness && hit.second!=MarkPart::Rotation) hit={-1,MarkPart::None};
     SetCursor(actionCursor(c,hit,inside || c.dragging));
@@ -764,7 +854,18 @@ void drawHandles(HDC dc, const Capture &c)
         handle({m.from.x+m.radius,m.from.y});
     }
     else {
-        handle(m.from); handle(m.to);
+        if(m.shape==ScreenshotShape::Triangle) {
+            auto vertices=shapeOutline(m);
+            for(size_t i=0;i<3;++i) handle(vertices[i]);
+        } else { handle(rotateShapePoint(m,m.from)); handle(rotateShapePoint(m,m.to)); }
+        if(m.shape!=ScreenshotShape::None) {
+            auto r=region(m.from,m.to);
+            auto top=point(rotateShapePoint(m,{(r.left+r.right)/2,r.top}));
+            auto grip=screenshotShapeRotationHandle(m,double(c.unit)*c.image->width/std::max(1L,c.view.right-c.view.left));
+            auto end=point(grip); MoveToEx(dc,top.x,top.y,nullptr); LineTo(dc,end.x,end.y);
+            int radius=std::max(4,c.unit/8);
+            Ellipse(dc,end.x-radius,end.y-radius,end.x+radius+1,end.y+radius+1);
+        }
         auto [from,to]=thicknessSegment(m);
         auto mid=point({(from.x+to.x)/2,(from.y+to.y)/2});
         auto grip=thicknessHandle(c,m),end=point(grip);
@@ -780,7 +881,8 @@ void drawTool(const DRAWITEMSTRUCT &item, const Capture &c)
     RECT r=item.rcItem;
     bool active=(item.CtlID==27 && c.pointer)||(item.CtlID==10 && !c.pointer && !c.arrow && !c.highlight && !c.freehand && !c.textTool)||(item.CtlID==11 && c.arrow && !c.straight && c.shape==ScreenshotShape::None)||
                 (item.CtlID==19 && c.highlight)||(item.CtlID==21 && c.freehand)||
-                (item.CtlID==22 && c.straight)||(item.CtlID>=23 && item.CtlID<=25 && int(c.shape)==int(item.CtlID)-22)||(item.CtlID==26 && c.textTool);
+                (item.CtlID==22 && c.straight)||(item.CtlID>=23 && item.CtlID<=25 && int(c.shape)==int(item.CtlID)-22)||(item.CtlID==26 && c.textTool)||
+                (item.CtlID==36 && c.shape==ScreenshotShape::Triangle)||(item.CtlID==37 && c.shape==ScreenshotShape::Trapezoid);
     bool disabled=item.itemState&ODS_DISABLED;
     POINT mouse; GetCursorPos(&mouse); ScreenToClient(item.hwndItem,&mouse);
     bool hover=PtInRect(&r,mouse) && !disabled;
@@ -794,7 +896,16 @@ void drawTool(const DRAWITEMSTRUCT &item, const Capture &c)
     RoundRect(dc,r.left,r.top,r.right,r.bottom,corner,corner);
     SelectObject(dc,oldPen); SelectObject(dc,oldBrush); DeleteObject(pen); DeleteObject(brush);
     int iconIndex=item.CtlID==35?13:item.CtlID==34?14:item.CtlID>=22?int(item.CtlID)-13:item.CtlID==18?5:item.CtlID==19?6:item.CtlID==20?7:item.CtlID==21?8:item.CtlID-10;
-    auto icon=item.CtlID==27?(HICON)LoadCursorW(nullptr,IDC_ARROW):c.toolIcons[disabled?2:active?1:0][iconIndex];
+    auto icon=(item.CtlID==36 || item.CtlID==37)?nullptr:item.CtlID==27?(HICON)LoadCursorW(nullptr,IDC_ARROW):c.toolIcons[disabled?2:active?1:0][iconIndex];
+    if(item.CtlID==36 || item.CtlID==37) {
+        int cx=(r.left+r.right)/2,cy=(r.top+r.bottom)/2,s=c.iconSize/2;
+        auto trianglePen=CreatePen(PS_SOLID,std::max(1,MulDiv(2,GetDpiForWindow(item.hwndItem),96)),
+                                  disabled?RGB(148,163,184):active?RGB(37,99,235):RGB(51,65,85));
+        auto previous=SelectObject(dc,trianglePen);
+        if(item.CtlID==36) { POINT vertices[]{{cx,cy-s},{cx+s,cy+s},{cx-s,cy+s},{cx,cy-s}}; Polyline(dc,vertices,4); }
+        else { POINT vertices[]{{cx-s/2,cy-s},{cx+s/2,cy-s},{cx+s,cy+s},{cx-s,cy+s},{cx-s/2,cy-s}}; Polyline(dc,vertices,5); }
+        SelectObject(dc,previous); DeleteObject(trianglePen);
+    }
     if(icon) DrawIconEx(dc,(r.right-c.iconSize)/2,(r.bottom-c.iconSize)/2,icon,c.iconSize,c.iconSize,0,nullptr,DI_NORMAL);
     if(item.CtlID==20) {
         auto color=c.selected>=0?c.marks[c.selected].color:c.currentColor;
@@ -913,7 +1024,7 @@ void edit(HWND w, Capture &c)
     InitCommonControlsEx(&statusControls);
     CreateWindowExW(0,STATUSCLASSNAMEW,L"",WS_CHILD|WS_VISIBLE|SBARS_TOOLTIPS,
         0,0,0,0,w,(HMENU)50,c.app.instance,nullptr);
-    const wchar_t *labels[]{L"Pointer (V): select and edit objects", L"Number (N)", L"Arrow (A); Ctrl+drag between objects to link", L"Straight line (L); Ctrl+drag between objects to link", L"Rectangle (R)", L"Circle (O)", L"Ellipse (E)", L"Freehand line (F); Shift for 45-degree steps; move >50 px off line to turn; Ctrl to draw over objects", L"Highlight (H); Ctrl+drag to paint over an object",
+    const wchar_t *labels[]{L"Pointer (V): select and edit objects", L"Number (N)", L"Arrow (A); Ctrl+drag between objects to link", L"Straight line (L); Ctrl+drag between objects to link", L"Rectangle (R)", L"Circle (O)", L"Ellipse (E)", L"Triangle (G): drag to draw; drag each vertex to reshape", L"Trapezoid (B): drag to draw", L"Freehand line (F); Shift for 45-degree steps; move >50 px off line to turn; Ctrl to draw over objects", L"Highlight (H); Ctrl+drag to paint over an object",
         L"Text (T); double-click or F2 to edit", L"Color — selected object and new objects", L"Undo (Ctrl+Z)", L"Redo (Ctrl+Y / Ctrl+Shift+Z)", L"Copy (Ctrl+C)"};
     static_assert(std::size(labels)==std::size(ToolIds));
     auto saveButton=CreateWindowW(L"BUTTON",L"Save...",WS_CHILD|WS_VISIBLE|WS_TABSTOP|BS_PUSHBUTTON,
@@ -1008,7 +1119,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             }
             break;
         case WM_DRAWITEM:
-            if((wp>=10 && wp<=13) || (wp>=18 && wp<=27) || wp==34 || wp==35) { drawTool(*reinterpret_cast<DRAWITEMSTRUCT *>(lp),*c); return TRUE; }
+            if((wp>=10 && wp<=13) || (wp>=18 && wp<=27) || wp==34 || wp==35 || wp==36 || wp==37) { drawTool(*reinterpret_cast<DRAWITEMSTRUCT *>(lp),*c); return TRUE; }
             break;
         case WM_CTLCOLORSTATIC:
             SetBkColor((HDC)wp,RGB(255,255,255)); SetTextColor((HDC)wp,RGB(51,65,85));
@@ -1102,13 +1213,13 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 if(changed) { c->copied=false; c->selected=-1; c->selectedLabel=false; c->wheelDelta=0; c->wheelTarget=-1; }
                 c->syncHistory();
             }
-            if (LOWORD(wp)==10 || LOWORD(wp)==11 || LOWORD(wp)==19 || (LOWORD(wp)>=21 && LOWORD(wp)<=27))
+            if (LOWORD(wp)==10 || LOWORD(wp)==11 || LOWORD(wp)==19 || LOWORD(wp)==36 || LOWORD(wp)==37 || (LOWORD(wp)>=21 && LOWORD(wp)<=27))
             {
                 c->pointer=LOWORD(wp)==27;
-                c->arrow = LOWORD(wp)==11 || (LOWORD(wp)>=22 && LOWORD(wp)<=25);
+                c->arrow = LOWORD(wp)==11 || LOWORD(wp)==36 || LOWORD(wp)==37 || (LOWORD(wp)>=22 && LOWORD(wp)<=25);
                 c->straight=LOWORD(wp)==22;
                 c->textTool=LOWORD(wp)==26;
-                c->shape=LOWORD(wp)>=23 && LOWORD(wp)<=25?ScreenshotShape(LOWORD(wp)-22):ScreenshotShape::None;
+                c->shape=LOWORD(wp)==37?ScreenshotShape::Trapezoid:LOWORD(wp)==36?ScreenshotShape::Triangle:LOWORD(wp)>=23 && LOWORD(wp)<=25?ScreenshotShape(LOWORD(wp)-22):ScreenshotShape::None;
                 c->selected=-1; c->selectedLabel=false;
                 c->highlight=LOWORD(wp)==19;
                 c->freehand=LOWORD(wp)==21;
@@ -1119,12 +1230,15 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 InvalidateRect(GetDlgItem(w,19),nullptr,FALSE);
                 InvalidateRect(GetDlgItem(w,21),nullptr,FALSE);
                 for(int id=22;id<=27;++id) InvalidateRect(GetDlgItem(w,id),nullptr,FALSE);
+                InvalidateRect(GetDlgItem(w,36),nullptr,FALSE);
+                InvalidateRect(GetDlgItem(w,37),nullptr,FALSE);
             }
 
             SetFocus(w); captureCursor(w,*c); InvalidateRect(w,nullptr,FALSE); return 0;
         case WM_KEYDOWN:
             if(wp==VK_SHIFT && c->editing && c->dragging && c->freehand && c->part==MarkPart::None && !c->strokeConstrained) {
                 c->strokeConstrained=true;
+                c->strokeUsedConstraint=true;
                 c->strokeAnchor=c->stroke.points.size()-1;
                 c->strokeAxis=0;
                 c->strokeAxisSettled=false;
@@ -1136,6 +1250,12 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             }
             if (c->editing && !c->dragging)
             {
+                if((GetKeyState(VK_CONTROL)&0x8000) &&
+                   (wp==VK_OEM_PLUS || wp==VK_ADD || wp==VK_OEM_MINUS || wp==VK_SUBTRACT || wp=='0' || wp==VK_NUMPAD0)) {
+                    POINT center{(c->canvas.left+c->canvas.right)/2,(c->canvas.top+c->canvas.bottom)/2};
+                    zoomCanvas(w,*c,wp==VK_OEM_MINUS || wp==VK_SUBTRACT?1/1.25:1.25,center,wp=='0' || wp==VK_NUMPAD0);
+                    return 0;
+                }
                 if(wp>=VK_LEFT && wp<=VK_DOWN && c->selected>=0 && !c->inlineText) {
                     POINT delta{wp==VK_LEFT?-1L:wp==VK_RIGHT?1L:0L,wp==VK_UP?-1L:wp==VK_DOWN?1L:0L};
                     const auto &original=c->marks[c->selected];
@@ -1170,6 +1290,8 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                     if(wp=='R') SendMessageW(w,WM_COMMAND,23,0);
                     if(wp=='O') SendMessageW(w,WM_COMMAND,24,0);
                     if(wp=='E') SendMessageW(w,WM_COMMAND,25,0);
+                    if(wp=='G') SendMessageW(w,WM_COMMAND,36,0);
+                    if(wp=='B') SendMessageW(w,WM_COMMAND,37,0);
                 }
                 if (wp=='N' || wp=='A') SendMessageW(w,WM_COMMAND,wp=='N'?10:11,0);
                 if(wp=='H') SendMessageW(w,WM_COMMAND,19,0);
@@ -1194,7 +1316,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
         case WM_LBUTTONDBLCLK:
             if(c->editing && !c->dragging) {
                 POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
-                if(PtInRect(&c->view,p)) {
+                if(PtInRect(&c->view,p) && PtInRect(&c->canvas,p)) {
                     auto [index,part]=markAt(*c,imagePoint(*c,p));
                     if(index>=0 && (c->marks[index].isText() || c->marks[index].isLine())) {
                         c->selected=index; beginMarkText(w,*c,index);
@@ -1204,8 +1326,10 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             return 0;
         case WM_LBUTTONDOWN:
         {
+            if(c->panning) return 0;
             finishInlineText(w,*c,true);
             POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
+            if(c->editing && !PtInRect(&c->canvas,p)) return 0;
             auto hitPart=c->editing?markAt(*c,imagePoint(*c,p,false)).second:MarkPart::None;
             bool thickness=hitPart==MarkPart::Thickness || hitPart==MarkPart::Rotation;
             if (c->editing && !PtInRect(&c->view,p) && !thickness)
@@ -1248,6 +1372,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                     c->stroke.freehand=c->freehand; c->stroke.style=c->lineStyle; c->stroke.ends=c->freehandEnds;
                     c->stroke.points.push_back(p);
                     c->strokeConstrained=false;
+                    c->strokeUsedConstraint=(wp&MK_SHIFT)!=0;
                 }
                 c->dragging=true; SetCapture(w);
             }
@@ -1255,8 +1380,17 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
         }
         case WM_MOUSEWHEEL:
         {
-            if(!c->editing || c->dragging) return 0;
+            if(!c->editing || c->dragging || c->panning) return 0;
             POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)}; ScreenToClient(w,&p);
+            if(!PtInRect(&c->canvas,p)) return 0;
+            if(GET_KEYSTATE_WPARAM(wp)&MK_CONTROL) {
+                c->wheelDelta=0; c->wheelTarget=-1;
+                c->zoomWheelDelta+=GET_WHEEL_DELTA_WPARAM(wp);
+                int steps=c->zoomWheelDelta/WHEEL_DELTA; c->zoomWheelDelta%=WHEEL_DELTA;
+                if(steps) zoomCanvas(w,*c,std::pow(1.25,steps),p);
+                return 0;
+            }
+            c->zoomWheelDelta=0;
             if(!PtInRect(&c->view,p)) return 0;
             auto [index,part]=markAt(*c,imagePoint(*c,p));
             if(index<0) { c->wheelDelta=0; c->wheelTarget=-1; return 0; }
@@ -1276,8 +1410,27 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             }
             return 0;
         }
+        case WM_MBUTTONDOWN:
+        {
+            POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
+            if(c->editing && !c->dragging && PtInRect(&c->canvas,p)) {
+                c->panning=true; c->panOrigin=p; SetCapture(w); SetCursor(LoadCursorW(nullptr,IDC_SIZEALL));
+            }
+            return 0;
+        }
+        case WM_MBUTTONUP:
+            if(c->panning) { c->panning=false; ReleaseCapture(); captureCursor(w,*c); }
+            return 0;
         case WM_MOUSEMOVE:
         case WM_LBUTTONUP:
+            if(c->panning) {
+                if(msg==WM_MOUSEMOVE) {
+                    POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
+                    c->panX+=p.x-c->panOrigin.x; c->panY+=p.y-c->panOrigin.y; c->panOrigin=p;
+                    layout(w,*c); positionInlineText(*c); SetCursor(LoadCursorW(nullptr,IDC_SIZEALL));
+                }
+                return 0;
+            }
             if (c->dragging)
             {
                 POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
@@ -1286,6 +1439,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                     c->end=constrainScreenshotShape(c->shape,c->start,c->end,c->image->width,c->image->height);
                 if(c->editing && (c->highlight || c->freehand) && c->part==MarkPart::None) {
                     bool constrained=c->freehand && ((wp&MK_SHIFT) || (GetKeyState(VK_SHIFT)&0x8000));
+                    c->strokeUsedConstraint=c->strokeUsedConstraint || constrained;
                     if(constrained) {
                         if(!c->strokeConstrained) {
                             c->strokeAnchor=c->stroke.points.size()-1;
@@ -1379,6 +1533,23 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                             linkScreenshotEndpoint(mark,false,c->end,c->marks,6);
                             resolveScreenshotLinks(c->marks);
                         }
+                        if(c->freehand && !c->strokeUsedConstraint &&
+                           !c->marks.back().fromNumber && !c->marks.back().toNumber &&
+                           !c->marks.back().fromLink.target && !c->marks.back().toLink.target) {
+                            ScreenshotShape recognized{};
+                            auto improved=improveScreenshotStroke(c->marks.back().points,&recognized);
+                            if(!improved.empty()) {
+                                c->remember(c->marks);
+                                auto &mark=c->marks.back();
+                                mark.points=std::move(improved);
+                                mark.from=mark.points.front(); mark.to=mark.points.back();
+                                if(recognized!=ScreenshotShape::None) {
+                                    mark.shape=recognized; mark.freehand=false; mark.ends=LineEnds::None;
+                                    auto bounds=markBounds(mark);
+                                    mark.from={bounds.left,bounds.top}; mark.to={bounds.right,bounds.bottom};
+                                }
+                            }
+                        }
                         c->selected=int(c->marks.size())-1; c->selectedLabel=false;
                     }
                     else if (std::hypot(double(c->end.x-c->start.x),double(c->end.y-c->start.y))>=4)
@@ -1389,6 +1560,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                         c->marks.back().style=c->lineStyle; c->marks.back().ends=c->straight || c->shape!=ScreenshotShape::None?LineEnds::None:c->arrowEnds;
                         c->marks.back().shape=c->shape;
                         auto &mark=c->marks.back();
+                        if(mark.shape==ScreenshotShape::Triangle || mark.shape==ScreenshotShape::Trapezoid) mark.points=shapeOutline(mark);
                         linkScreenshotEndpoint(mark,true,c->start,c->marks,6);
                         linkScreenshotEndpoint(mark,false,c->end,c->marks,6);
                         resolveScreenshotLinks(c->marks);
@@ -1401,6 +1573,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             captureCursor(w,*c);
             return 0;
         case WM_CAPTURECHANGED:
+            c->panning=false;
             if(c->dragging && c->part!=MarkPart::None)
             {
                 c->marks=std::move(c->beforeDrag); c->part=MarkPart::None;
@@ -1410,7 +1583,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             if (c->editing)
             {
                 auto limits = reinterpret_cast<MINMAXINFO *>(lp);
-                limits->ptMinTrackSize = {MulDiv(650,GetDpiForWindow(w),96),MulDiv(240,GetDpiForWindow(w),96)};
+                limits->ptMinTrackSize = {MulDiv(730,GetDpiForWindow(w),96),MulDiv(240,GetDpiForWindow(w),96)};
                 return 0;
             }
             break;
@@ -1460,7 +1633,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                     auto previous=SelectObject(buffer,divider);
                     MoveToEx(buffer,0,c->panelHeight-1,nullptr); LineTo(buffer,client.right,c->panelHeight-1);
                     int dpi=GetDpiForWindow(w);
-                    for(int x:{368,452}) {
+                    for(int x:{440,524}) {
                         MoveToEx(buffer,MulDiv(x,dpi,96),MulDiv(13,dpi,96),nullptr);
                         LineTo(buffer,MulDiv(x,dpi,96),MulDiv(31,dpi,96));
                     }
@@ -1478,9 +1651,12 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                     }
                     drawMarks(rendered.dc,visibleMarks,c->dragging && c->part==MarkPart::None?((c->highlight || c->freehand)?&c->stroke:&preview):nullptr);
                     SetStretchBltMode(buffer,HALFTONE); SetBrushOrgEx(buffer,0,0,nullptr);
+                    int savedCanvas=SaveDC(buffer);
+                    IntersectClipRect(buffer,c->canvas.left,c->canvas.top,c->canvas.right,c->canvas.bottom);
                     StretchBlt(buffer,c->view.left,c->view.top,c->view.right-c->view.left,c->view.bottom-c->view.top,
                                rendered.dc,0,0,rendered.width,rendered.height,SRCCOPY);
                     drawHandles(buffer,*c);
+                    RestoreDC(buffer,savedCanvas);
                     BitBlt(dc,0,0,width,height,buffer,0,0,SRCCOPY);
                 }
             }
@@ -1525,6 +1701,11 @@ POINT screenshotTextRotationHandle(const ScreenshotMark &m,double clearance)
     auto r=plainTextBounds(m);
     return rotateTextPoint(m,{(r.left+r.right)/2,r.top-LONG(std::lround(clearance))});
 }
+POINT screenshotShapeRotationHandle(const ScreenshotMark &m,double clearance)
+{
+    auto r=region(m.from,m.to);
+    return rotateShapePoint(m,{(r.left+r.right)/2,r.top-LONG(std::lround(clearance))});
+}
 ScreenshotMark screenshotArrowLabel(const ScreenshotMark &m)
 {
     ScreenshotMark label{{0,0},{0,0},0};
@@ -1604,23 +1785,23 @@ void assignMarkIds(std::vector<ScreenshotMark> &marks)
 }
 POINT objectAnchor(const ScreenshotMark &m,const ScreenshotLink &link)
 {
-    if(m.isText() || m.shape!=ScreenshotShape::None) {
+    if(m.isText() || (m.shape!=ScreenshotShape::None && m.points.empty())) {
         auto r=m.isText()?plainTextBounds(m):region(m.from,m.to);
         POINT p{LONG(std::lround(r.left+(r.right-r.left)*link.u)),LONG(std::lround(r.top+(r.bottom-r.top)*link.v))};
-        return m.isText()?rotateTextPoint(m,p):p;
+        return m.isText()?rotateTextPoint(m,p):rotateShapePoint(m,p);
     }
     size_t segments=m.points.size()>1?m.points.size()-1:1;
     double along=std::clamp(link.u,0.0,1.0)*segments;
     size_t i=std::min(size_t(along),segments-1); double t=along-i;
     POINT a=m.points.size()>1?m.points[i]:m.from,b=m.points.size()>1?m.points[i+1]:m.to;
-    return {LONG(std::lround(a.x+(b.x-a.x)*t)),LONG(std::lround(a.y+(b.y-a.y)*t))};
+    return rotateShapePoint(m,{LONG(std::lround(a.x+(b.x-a.x)*t)),LONG(std::lround(a.y+(b.y-a.y)*t))});
 }
 bool findObjectAnchor(const ScreenshotMark &m,POINT drop,double tolerance,ScreenshotLink &link)
 {
     link={m.id,0,0};
-    if(m.isText() || m.shape!=ScreenshotShape::None) {
+    if(m.isText() || (m.shape!=ScreenshotShape::None && m.points.empty())) {
         auto r=m.isText()?plainTextBounds(m):region(m.from,m.to);
-        POINT p=m.isText()?rotateTextPoint(m,drop,-1):drop;
+        POINT p=m.isText()?rotateTextPoint(m,drop,-1):rotateShapePoint(m,drop,-1);
         double w=std::max(1L,r.right-r.left),h=std::max(1L,r.bottom-r.top);
         double x=(p.x-r.left)/w,y=(p.y-r.top)/h;
         bool inside=x>=0 && x<=1 && y>=0 && y<=1;
@@ -1640,6 +1821,7 @@ bool findObjectAnchor(const ScreenshotMark &m,POINT drop,double tolerance,Screen
         auto anchor=objectAnchor(m,link);
         return inside || std::hypot(double(drop.x-anchor.x),double(drop.y-anchor.y))<=tolerance;
     }
+    drop=rotateShapePoint(m,drop,-1);
     double best=1e100;
     size_t segments=m.points.size()>1?m.points.size()-1:1;
     for(size_t i=0;i<segments;++i) {
@@ -1724,6 +1906,13 @@ void resolveScreenshotLinks(std::vector<ScreenshotMark> &marks)
 }
 MarkPart hitScreenshotMark(const ScreenshotMark &m, POINT p, double tolerance)
 {
+    if(m.shape==ScreenshotShape::Triangle) {
+        auto vertices=shapeOutline(m);
+        for(int i=0;i<3;++i)
+            if(std::hypot(double(p.x-vertices[i].x),double(p.y-vertices[i].y))<=tolerance)
+                return MarkPart(int(MarkPart::Vertex0)+i);
+    }
+    p=rotateShapePoint(m,p,-1);
     if(m.isText()) {
         auto r=plainTextBounds(m);
         auto local=rotateTextPoint(m,p,-1);
@@ -1734,8 +1923,10 @@ MarkPart hitScreenshotMark(const ScreenshotMark &m, POINT p, double tolerance)
     auto distance=[](POINT a, POINT b) { return std::hypot(double(a.x-b.x),double(a.y-b.y)); };
     if(!m.points.empty())
     {
-        if(m.freehand && distance(p,m.from)<=tolerance) return MarkPart::Start;
-        if(m.freehand && distance(p,m.to)<=tolerance) return MarkPart::End;
+        if(m.shape!=ScreenshotShape::Triangle) {
+            if((m.freehand || m.shape!=ScreenshotShape::None) && distance(p,m.from)<=tolerance) return MarkPart::Start;
+            if((m.freehand || m.shape!=ScreenshotShape::None) && distance(p,m.to)<=tolerance) return MarkPart::End;
+        }
         double reach=tolerance+std::clamp(m.thickness,m.isHighlight()?4:1,m.isHighlight()?100:30)/2.0;
         POINT from=m.points.front();
         for(auto to:m.points) {
@@ -1789,7 +1980,32 @@ ScreenshotMark dragScreenshotMark(const ScreenshotMark &original, MarkPart part,
 {
     auto m=original;
     if(position.x==origin.x && position.y==origin.y) return m;
-    if(part==MarkPart::Rotation && (m.isText() || (m.isLine() && !m.label.empty()))) {
+    if(part>=MarkPart::Vertex0 && part<=MarkPart::Vertex2 && m.shape==ScreenshotShape::Triangle) {
+        if(m.points.empty()) { auto local=m; local.rotation=0; m.points=shapeOutline(local); }
+        size_t index=size_t(int(part)-int(MarkPart::Vertex0)),fixed=(index+1)%3;
+        auto fixedWorld=rotateShapePoint(m,m.points[fixed]);
+        auto vertexWorld=rotateShapePoint(m,m.points[index]);
+        POINT target{std::clamp(vertexWorld.x+position.x-origin.x,0L,LONG(width-1)),
+                     std::clamp(vertexWorld.y+position.y-origin.y,0L,LONG(height-1))};
+        m.points[index]=rotateShapePoint(m,target,-1); m.points[3]=m.points[0];
+        RECT bounds{m.points[0].x,m.points[0].y,m.points[0].x,m.points[0].y};
+        for(size_t i=1;i<3;++i) {auto p=m.points[i]; bounds.left=std::min(bounds.left,p.x); bounds.right=std::max(bounds.right,p.x);
+            bounds.top=std::min(bounds.top,p.y); bounds.bottom=std::max(bounds.bottom,p.y);}
+        m.from={bounds.left,bounds.top}; m.to={bounds.right,bounds.bottom};
+        auto shifted=rotateShapePoint(m,m.points[fixed]);
+        LONG dx=fixedWorld.x-shifted.x,dy=fixedWorld.y-shifted.y;
+        m.from.x+=dx; m.to.x+=dx; m.from.y+=dy; m.to.y+=dy;
+        for(auto &p:m.points) {p.x+=dx;p.y+=dy;}
+    }
+    else if(part==MarkPart::Rotation && m.shape!=ScreenshotShape::None) {
+        double cx=(m.from.x+m.to.x)/2.0,cy=(m.from.y+m.to.y)/2.0;
+        if(std::hypot(position.x-cx,position.y-cy)<1) return m;
+        double a=std::atan2(origin.y-cy,origin.x-cx),b=std::atan2(position.y-cy,position.x-cx);
+        m.rotation+=(b-a)*180/3.141592653589793;
+        if(snapRotation) m.rotation=std::round(m.rotation/15)*15;
+        m.rotation=std::remainder(m.rotation,360);
+    }
+    else if(part==MarkPart::Rotation && (m.isText() || (m.isLine() && !m.label.empty()))) {
         if(position.x==origin.x && position.y==origin.y) return m;
         auto text=m.isText()?m:screenshotArrowLabel(m);
         auto r=plainTextBounds(text);
@@ -1843,13 +2059,34 @@ ScreenshotMark dragScreenshotMark(const ScreenshotMark &original, MarkPart part,
     }
     else if(part==MarkPart::Start || part==MarkPart::End)
     {
+        origin=rotateShapePoint(original,origin,-1);
+        position=rotateShapePoint(original,position,-1);
         (part==MarkPart::Start?m.fromNumber:m.toNumber)=0;
         (part==MarkPart::Start?m.fromLink:m.toLink)={};
         auto &endpoint=part==MarkPart::Start?m.from:m.to;
         endpoint.x=std::clamp(endpoint.x+position.x-origin.x,0L,LONG(width-1));
         endpoint.y=std::clamp(endpoint.y+position.y-origin.y,0L,LONG(height-1));
         endpoint=constrainScreenshotShape(m.shape,part==MarkPart::Start?m.to:m.from,endpoint,width,height);
+        if(m.shape!=ScreenshotShape::None && !m.points.empty()) {
+            if(m.from.x==m.to.x || m.from.y==m.to.y) return original;
+            // Resize the entire recognized outline, not just a pencil endpoint.
+            // Keep the opposite corner fixed, including when dragging across it.
+            double oldWidth=original.to.x-original.from.x,oldHeight=original.to.y-original.from.y;
+            for(auto &point:m.points) {
+                double u=oldWidth?(point.x-original.from.x)/oldWidth:0;
+                double v=oldHeight?(point.y-original.from.y)/oldHeight:0;
+                point={LONG(std::lround(m.from.x+u*(m.to.x-m.from.x))),
+                       LONG(std::lround(m.from.y+v*(m.to.y-m.from.y)))};
+            }
+        }
         if(m.freehand && !m.points.empty()) (part==MarkPart::Start?m.points.front():m.points.back())=endpoint;
+        if(m.shape!=ScreenshotShape::None && m.rotation!=0) {
+            auto fixedBefore=rotateShapePoint(original,part==MarkPart::Start?original.to:original.from);
+            auto fixedAfter=rotateShapePoint(m,part==MarkPart::Start?m.to:m.from);
+            LONG dx=fixedBefore.x-fixedAfter.x,dy=fixedBefore.y-fixedAfter.y;
+            m.from.x+=dx; m.to.x+=dx; m.from.y+=dy; m.to.y+=dy;
+            for(auto &p:m.points) {p.x+=dx;p.y+=dy;}
+        }
     }
     return m;
 }

src/screenshot.h

@@ -15,7 +15,7 @@ void showScreenshot(ScreenshotHost &);
 void showScreenshotEditor(ScreenshotHost &,const Clip &);
 enum class LineStyle { Solid, Dotted, Dashed, DashDot };
 enum class LineEnds { End, Start, Both, None };
-enum class ScreenshotShape { None, Rectangle, Circle, Ellipse };
+enum class ScreenshotShape { None, Rectangle, Circle, Ellipse, Triangle, Trapezoid };
 struct ScreenshotOffset { double x, y; };
 struct ScreenshotLink {
     unsigned long long target{};
@@ -40,7 +40,7 @@ struct ScreenshotMark {
     unsigned long long id{};
     ScreenshotLink fromLink, toLink;
     bool isText() const { return !text.empty(); }
-    bool isHighlight() const { return !points.empty() && !freehand; }
+    bool isHighlight() const { return !points.empty() && !freehand && shape==ScreenshotShape::None; }
     bool isLine() const { return !number && !isText() && !isHighlight() && shape==ScreenshotShape::None; }
 };
 class ScreenshotHistory {
@@ -55,7 +55,7 @@ class ScreenshotHistory {
 void resolveScreenshotLinks(std::vector<ScreenshotMark> &);
 void linkScreenshotEndpoint(ScreenshotMark &, bool start, POINT drop,
                             std::vector<ScreenshotMark> &, double tolerance);
-enum class MarkPart { None, Body, Start, End, Radius, Thickness, Rotation, Label };
+enum class MarkPart { None, Body, Start, End, Radius, Thickness, Rotation, Label, Vertex0, Vertex1, Vertex2 };
 POINT screenshotThicknessHandle(const ScreenshotMark &, double clearance = 16);
 ScreenshotMark cloneScreenshotMark(const ScreenshotMark &, const std::vector<ScreenshotMark> &, int width, int height);
 int nextScreenshotNumber(const std::vector<ScreenshotMark> &);
@@ -65,6 +65,7 @@ ScreenshotMark dragScreenshotMark(const ScreenshotMark &, MarkPart, POINT origin
 POINT constrainScreenshotShape(ScreenshotShape, POINT anchor, POINT position, int width, int height);
 RECT screenshotTextBounds(const ScreenshotMark &);
 POINT screenshotTextRotationHandle(const ScreenshotMark &, double clearance=24);
+POINT screenshotShapeRotationHandle(const ScreenshotMark &, double clearance=32);
 ScreenshotMark screenshotArrowLabel(const ScreenshotMark &);
 // Render at source resolution; never reads or writes the system clipboard.
 Clip screenshotClip(HDC source, int width, int height, const std::vector<ScreenshotMark> &marks);

src/stroke_improvement.h

@@ -0,0 +1,218 @@
+#pragma once
+#include "screenshot.h"
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+namespace ks::stroke_detail {
+struct Point { double x, y; };
+inline double distance(Point a, Point b) { return std::hypot(a.x-b.x,a.y-b.y); }
+inline double length(const std::vector<Point> &p) {
+    double total=0;
+    for(size_t i=1;i<p.size();++i) total+=distance(p[i-1],p[i]);
+    return total;
+}
+// Arc-length sampling makes fitting independent of mouse speed and bounds its cost.
+inline std::vector<Point> sample(const std::vector<Point> &p, size_t count) {
+    std::vector<Point> out{p.front()};
+    double step=length(p)/(count-1), traversed=0;
+    size_t segment=1;
+    for(size_t i=1;i+1<count;++i) {
+        double target=i*step;
+        while(segment+1<p.size() && traversed+distance(p[segment-1],p[segment])<target) {
+            traversed+=distance(p[segment-1],p[segment]); ++segment;
+        }
+        double span=distance(p[segment-1],p[segment]);
+        double t=span>0?(target-traversed)/span:0;
+        out.push_back({p[segment-1].x+t*(p[segment].x-p[segment-1].x),
+                       p[segment-1].y+t*(p[segment].y-p[segment-1].y)});
+    }
+    out.push_back(p.back()); return out;
+}
+inline double segmentDistance(Point p, Point a, Point b) {
+    double dx=b.x-a.x,dy=b.y-a.y,den=dx*dx+dy*dy;
+    double t=den?std::clamp(((p.x-a.x)*dx+(p.y-a.y)*dy)/den,0.0,1.0):0;
+    return distance(p,{a.x+t*dx,a.y+t*dy});
+}
+inline double cross(Point a, Point b, Point c) { return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x); }
+}
+
+namespace ks {
+// Returns a replacement path; an empty result means no visible improvement.
+// Report recognized geometry separately from a smoothed freehand path.
+inline std::vector<POINT> improveScreenshotStroke(const std::vector<POINT> &input, ScreenshotShape *shape=nullptr) {
+    if(shape) *shape=ScreenshotShape::None;
+    using namespace stroke_detail;
+    if(input.size()<5) return {};
+    std::vector<Point> raw;
+    for(auto p:input) if(raw.empty() || distance(raw.back(),{double(p.x),double(p.y)})>0)
+        raw.push_back({double(p.x),double(p.y)});
+    double total=length(raw);
+    if(raw.size()<5 || total<16) return {};
+    auto points=sample(raw,128);
+    double left=points[0].x,right=left,top=points[0].y,bottom=top;
+    for(auto p:points) { left=std::min(left,p.x); right=std::max(right,p.x); top=std::min(top,p.y); bottom=std::max(bottom,p.y); }
+    double scale=std::min(right-left,bottom-top);
+    std::vector<Point> best;
+    double bestScore=1e30;
+    double gap=distance(raw.front(),raw.back());
+    if(scale>=20 && gap<=scale*.5) {
+        auto consider=[&](std::vector<Point> candidate, ScreenshotShape kind=ScreenshotShape::Rectangle) {
+            bool oval=kind==ScreenshotShape::Circle || kind==ScreenshotShape::Ellipse;
+            if(!oval && gap>scale*.22) return;
+            double perimeter=length(candidate);
+            if(total<perimeter*.82 || total>perimeter*1.25) return;
+            auto probes=sample(candidate,128);
+            double sum=0,maximum=0;
+            auto measure=[&](const std::vector<Point> &a,const std::vector<Point> &b) {
+                for(auto p:a) {
+                    double d=1e30;
+                    for(size_t i=1;i<b.size();++i) d=std::min(d,segmentDistance(p,b[i-1],b[i]));
+                    sum+=d*d; maximum=std::max(maximum,d);
+                }
+            };
+            measure(points,candidate); measure(probes,points);
+            double score=std::sqrt(sum/256);
+            if(maximum<=std::max(3.0,scale*(oval?.22:.12)) && score<=std::max(1.5,scale*(oval?.085:.055)) && score<bestScore) {
+                bestScore=score; best=std::move(candidate);
+                if(shape) *shape=kind;
+            }
+        };
+        // Fit oriented bounding boxes; testing angles also handles tilted ovals.
+        for(int degrees=0;degrees<180;degrees+=5) {
+            double angle=degrees*3.141592653589793/180,cs=std::cos(angle),sn=std::sin(angle);
+            double x0=1e30,y0=x0,x1=-x0,y1=-x0;
+            for(auto p:points) {
+                double x=p.x*cs+p.y*sn,y=-p.x*sn+p.y*cs;
+                x0=std::min(x0,x); x1=std::max(x1,x); y0=std::min(y0,y); y1=std::max(y1,y);
+            }
+            auto world=[&](double x,double y)->Point { return {x*cs-y*sn,x*sn+y*cs}; };
+            consider({world(x0,y0),world(x1,y0),world(x1,y1),world(x0,y1),world(x0,y0)});
+            double rx=(x1-x0)/2,ry=(y1-y0)/2;
+            double cx=(x0+x1)/2,cy=(y0+y1)/2;
+            std::vector<Point> local;
+            for(auto p:points) local.push_back({p.x*cs+p.y*sn,-p.x*sn+p.y*cs});
+            // Fit four sides to their supporting samples. Extremal bounds exaggerate
+            // crooked corners and can unfairly make an oval score better than a box.
+            double sides[]{x0,x1,y0,y1};
+            bool supported=true;
+            for(int iteration=0;iteration<6;++iteration) {
+                double sums[4]{}; int counts[4]{};
+                for(auto p:local) {
+                    double distances[]{std::abs(p.x-sides[0]),std::abs(p.x-sides[1]),
+                                       std::abs(p.y-sides[2]),std::abs(p.y-sides[3])};
+                    auto side=std::min_element(distances,distances+4)-distances;
+                    sums[side]+=side<2?p.x:p.y; ++counts[side];
+                }
+                for(int side=0;side<4;++side) {
+                    if(counts[side]<10) { supported=false; break; }
+                    sides[side]=sums[side]/counts[side];
+                }
+                if(!supported) break;
+            }
+            if(supported && sides[1]-sides[0]>=16 && sides[3]-sides[2]>=16)
+                consider({world(sides[0],sides[2]),world(sides[1],sides[2]),
+                          world(sides[1],sides[3]),world(sides[0],sides[3]),world(sides[0],sides[2])});
+            // Fit the whole gesture instead of letting a single mouse wobble set the bounds.
+            auto error=[&](double x,double y,double a,double b) {
+                if(a<8 || b<8) return 1e30;
+                double sum=0;
+                for(auto p:local) {
+                    double u=(p.x-x)/a,v=(p.y-y)/b,r=std::hypot(u,v);
+                    double normal=std::hypot(u/a,v/b);
+                    double d=normal>1e-9?(r-1)*r/normal:std::min(a,b);
+                    sum+=d*d;
+                }
+                return sum;
+            };
+            double fit=error(cx,cy,rx,ry),step=std::max(rx,ry)*.08;
+            for(int iteration=0;iteration<10;++iteration) {
+                for(int parameter=0;parameter<4;++parameter) for(int sign:{-1,1}) {
+                    double values[]{cx,cy,rx,ry}; values[parameter]+=sign*step;
+                    double next=error(values[0],values[1],values[2],values[3]);
+                    if(next<fit) { fit=next; cx=values[0]; cy=values[1]; rx=values[2]; ry=values[3]; }
+                }
+                step*=.65;
+            }
+            // Require almost one complete turn, with little retracing. This admits a small
+            // closing gap or overshoot but rejects C-shaped arcs, spirals and scribbles.
+            double turn=0,travel=0;
+            for(size_t i=1;i<local.size();++i) {
+                double a=std::atan2((local[i-1].y-cy)/ry,(local[i-1].x-cx)/rx);
+                double b=std::atan2((local[i].y-cy)/ry,(local[i].x-cx)/rx);
+                double delta=std::remainder(b-a,2*3.141592653589793);
+                turn+=delta; travel+=std::abs(delta);
+            }
+            if(std::abs(turn)<5.4 || std::abs(turn)>7.1 || travel-std::abs(turn)>.65) continue;
+            // Near-circular gestures become true circles.
+            bool circle=std::abs(rx-ry)<=std::max(rx,ry)*.12;
+            if(circle) rx=ry=(rx+ry)/2;
+            std::vector<Point> oval;
+            for(int i=0;i<96;++i) {
+                double t=i*2*3.141592653589793/96;
+                oval.push_back(world(cx+rx*std::cos(t),cy+ry*std::sin(t)));
+            }
+            oval.push_back(oval.front()); consider(std::move(oval),circle?ScreenshotShape::Circle:ScreenshotShape::Ellipse);
+        }
+        auto sorted=points;
+        std::sort(sorted.begin(),sorted.end(),[](Point a,Point b){return a.x<b.x || (a.x==b.x && a.y<b.y);});
+        std::vector<Point> hull;
+        for(auto p:sorted) {
+            while(hull.size()>1 && cross(hull[hull.size()-2],hull.back(),p)<=0) hull.pop_back();
+            hull.push_back(p);
+        }
+        size_t lower=hull.size();
+        for(size_t i=sorted.size()-1;i-->0;) {
+            auto p=sorted[i];
+            while(hull.size()>lower && cross(hull[hull.size()-2],hull.back(),p)<=0) hull.pop_back();
+            hull.push_back(p);
+        }
+        hull.pop_back();
+        while(hull.size()>3) {
+            if(hull.size()==4 && bestScore>scale*.035) {
+                // Opposite edges must already be nearly parallel; retain their unequal
+                // lengths and fit a shared direction instead of accepting any quadrilateral.
+                for(size_t i=0;i<2;++i) {
+                    Point a=hull[i],b=hull[i+1],c=hull[(i+2)%4],d=hull[(i+3)%4];
+                    double ab=distance(a,b),cd=distance(c,d);
+                    if(std::min(ab,cd)<16 || std::min(ab,cd)/std::max(ab,cd)>.8) continue;
+                    Point u{(b.x-a.x)/ab,(b.y-a.y)/ab},v{(c.x-d.x)/cd,(c.y-d.y)/cd};
+                    if(u.x*v.x+u.y*v.y<.96) continue;
+                    double norm=std::hypot(u.x+v.x,u.y+v.y);
+                    Point axis{(u.x+v.x)/norm,(u.y+v.y)/norm};
+                    auto along=[&](Point p){return p.x*axis.x+p.y*axis.y;};
+                    auto across=[&](Point p){return -p.x*axis.y+p.y*axis.x;};
+                    double y0=(across(a)+across(b))/2,y1=(across(c)+across(d))/2;
+                    if(std::abs(y1-y0)<20) continue;
+                    auto fit=[&](Point p,double y)->Point {double x=along(p);return {x*axis.x-y*axis.y,x*axis.y+y*axis.x};};
+                    std::vector<Point> candidate{fit(a,y0),fit(b,y0),fit(c,y1),fit(d,y1),fit(a,y0)};
+                    consider(std::move(candidate),ScreenshotShape::Trapezoid);
+                }
+            }
+            size_t remove=0; double area=1e30;
+            for(size_t i=0;i<hull.size();++i) {
+                double a=std::abs(cross(hull[(i+hull.size()-1)%hull.size()],hull[i],hull[(i+1)%hull.size()]));
+                if(a<area) { area=a; remove=i; }
+            }
+            hull.erase(hull.begin()+remove);
+        }
+        if(hull.size()==3) { hull.push_back(hull.front()); consider(hull,ScreenshotShape::Triangle); }
+    }
+    if(best.empty()) {
+        // A small spatial filter suppresses jitter without moving endpoints or flattening broad curves.
+        best=sample(raw,size_t(std::clamp(std::ceil(total/2)+1,5.0,2048.0)));
+        auto original=best;
+        for(size_t i=1;i+1<best.size();++i)
+            best[i]={(original[i-1].x+2*original[i].x+original[i+1].x)/4,
+                     (original[i-1].y+2*original[i].y+original[i+1].y)/4};
+    }
+    std::vector<POINT> result;
+    for(auto p:best) {
+        POINT q{LONG(std::lround(p.x)),LONG(std::lround(p.y))};
+        if(result.empty() || result.back().x!=q.x || result.back().y!=q.y) result.push_back(q);
+    }
+    if(result.size()==input.size() && std::equal(result.begin(),result.end(),input.begin(),
+       [](POINT a,POINT b){return a.x==b.x && a.y==b.y;})) return {};
+    return result;
+}
+}

src/update.h

@@ -2,7 +2,7 @@
 #include "platform.h"
 namespace ks
 {
-inline constexpr wchar_t AppVersion[] = L"0.6.23";
+inline constexpr wchar_t AppVersion[] = L"0.6.24";
 inline constexpr UINT UpdateMessage = WM_APP + 7;
 inline constexpr UINT UpdateCheckIntervalMs = 6 * 60 * 60 * 1000;
 inline constexpr UINT UpdateNotificationRetryMs = 5 * 60 * 1000;

tests/screenshot_ui.cpp

@@ -2,10 +2,12 @@
 // Including the implementation lets this integration test drive private editor state directly.
 #include "../src/screenshot.cpp"
 #include <iostream>
+#include "stroke_improvement.h"
 int main(int argc, char **argv)
 {
     CoInitializeEx(nullptr,COINIT_APARTMENTTHREADED);
     try {
+        testStrokeImprovement();
         if(argc>1 && std::string(argv[1])=="--save-only") {
             auto require=[](bool ok,const char *message){if(!ok) throw std::runtime_error(message);};
             auto root=std::filesystem::temp_directory_path()/(L"KSwitcher-save-"+std::to_wstring(GetCurrentProcessId()));
@@ -81,6 +83,169 @@ int main(int argc, char **argv)
         require(c.pencilCursor!=nullptr,"pencil drawing cursor loads");
         require(c.freehand && !c.pointer && ks::toolCursor(c)==c.pencilCursor,
                 "new screenshot editor starts with the pencil tool");
+        {
+            require(GetDlgItem(window,36)!=nullptr,"triangle has a dedicated toolbar button");
+            SendMessageW(window,WM_KEYDOWN,'G',0);
+            require(c.shape==ks::ScreenshotShape::Triangle && c.arrow && !c.freehand,"G selects triangle drawing tool");
+            auto mouse=[&](UINT message,POINT p) {
+                int x=c.view.left+MulDiv(p.x,c.view.right-c.view.left,c.image->width);
+                int y=c.view.top+MulDiv(p.y,c.view.bottom-c.view.top,c.image->height);
+                SendMessageW(window,message,message==WM_LBUTTONUP?0:MK_LBUTTON,MAKELPARAM(x,y));
+            };
+            mouse(WM_LBUTTONDOWN,{80,80}); mouse(WM_LBUTTONUP,{220,180});
+            require(c.marks.size()==1 && c.marks[0].shape==ks::ScreenshotShape::Triangle && c.marks[0].points.size()==4,
+                    "triangle tool creates a closed three-vertex shape");
+            auto triangle=c.marks[0];
+            for(double angle:{0.0,37.0,90.0,-125.0}) for(int i=0;i<3;++i) {
+                auto original=triangle; original.rotation=angle;
+                auto vertices=ks::shapeOutline(original);
+                auto part=ks::MarkPart(int(ks::MarkPart::Vertex0)+i);
+                require(ks::hitScreenshotMark(original,vertices[i],4)==part,"each rotated triangle vertex has its own handle");
+                POINT target{vertices[i].x+13,vertices[i].y-9};
+                auto changed=ks::dragScreenshotMark(original,part,vertices[i],target,320,240);
+                auto moved=ks::shapeOutline(changed);
+                for(int j=0;j<3;++j) {
+                    auto expected=j==i?target:vertices[j];
+                    require(std::abs(moved[j].x-expected.x)<=2 && std::abs(moved[j].y-expected.y)<=2,
+                            "dragging one vertex preserves both other world vertices after rotation");
+                }
+                require(changed.points.front().x==changed.points.back().x && changed.points.front().y==changed.points.back().y,
+                        "triangle remains closed after editing any vertex");
+            }
+            auto vertices=ks::shapeOutline(triangle);
+            mouse(WM_LBUTTONDOWN,vertices[0]);
+            require(c.part==ks::MarkPart::Vertex0,"mouse selects apex vertex");
+            mouse(WM_LBUTTONUP,{vertices[0].x+20,vertices[0].y+10});
+            require(c.marks[0].points[0].x==triangle.points[0].x+20 && c.marks[0].points[1].x==triangle.points[1].x,
+                    "mouse vertex drag changes only requested corner");
+            SendMessageW(window,WM_COMMAND,12,0);
+            require(c.marks[0].points[0].x==triangle.points[0].x,"undo restores triangle vertex");
+            SendMessageW(window,WM_COMMAND,18,0);
+            require(c.marks[0].points[0].x==triangle.points[0].x+20,"redo reapplies triangle vertex edit");
+            c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
+            require(GetDlgItem(window,37)!=nullptr,"trapezoid has a dedicated toolbar button");
+            SendMessageW(window,WM_KEYDOWN,'B',0);
+            require(c.shape==ks::ScreenshotShape::Trapezoid && c.arrow && !c.freehand,"B selects trapezoid tool");
+            mouse(WM_LBUTTONDOWN,{60,70}); mouse(WM_LBUTTONUP,{240,180});
+            require(c.marks.size()==1 && c.marks[0].shape==ks::ScreenshotShape::Trapezoid && c.marks[0].points.size()==5 && !c.marks[0].isHighlight(),
+                    "trapezoid tool creates a closed shape with unequal parallel bases");
+            auto trapezoid=c.marks[0];
+            require(trapezoid.points[0].y==trapezoid.points[1].y && trapezoid.points[2].y==trapezoid.points[3].y &&
+                    trapezoid.points[1].x-trapezoid.points[0].x<trapezoid.points[2].x-trapezoid.points[3].x,"toolbar trapezoid has parallel unequal bases");
+            mouse(WM_LBUTTONDOWN,trapezoid.to); mouse(WM_LBUTTONUP,{260,200});
+            require(c.marks[0].to.x==260 && c.marks[0].points[0].y==c.marks[0].points[1].y,"trapezoid resizes as a shape");
+            auto grip=ks::screenshotShapeRotationHandle(c.marks[0]);
+            auto rotated=ks::dragScreenshotMark(c.marks[0],ks::MarkPart::Rotation,grip,{280,135},320,240);
+            require(rotated.rotation!=0 && rotated.shape==ks::ScreenshotShape::Trapezoid,"trapezoid supports shape rotation");
+            SendMessageW(window,WM_COMMAND,12,0); require(c.marks[0].to.x==240,"undo trapezoid resize");
+            SendMessageW(window,WM_COMMAND,12,0); require(c.marks.empty(),"undo trapezoid creation");
+            SendMessageW(window,WM_COMMAND,18,0); require(c.marks[0].shape==ks::ScreenshotShape::Trapezoid,"redo trapezoid creation");
+            c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
+            SendMessageW(window,WM_COMMAND,21,0);
+        }
+        {
+            for(auto kind:{ks::ScreenshotShape::Rectangle,ks::ScreenshotShape::Circle,ks::ScreenshotShape::Ellipse,ks::ScreenshotShape::Triangle})
+            for(bool recognized:{false,true}) {
+                if(kind==ks::ScreenshotShape::Triangle && !recognized) continue;
+                ks::Mark shape{{100,90},{200,170},0}; shape.shape=kind; shape.ends=ks::LineEnds::None;
+                if(kind==ks::ScreenshotShape::Circle) shape.to.y=190;
+                if(recognized) shape.points=kind==ks::ScreenshotShape::Triangle?
+                    std::vector<POINT>{{150,90},{200,170},{100,170},{150,90}}:ks::shapeOutline(shape);
+                auto grip=ks::screenshotShapeRotationHandle(shape);
+                POINT center{(shape.from.x+shape.to.x)/2,(shape.from.y+shape.to.y)/2};
+                POINT right{center.x+center.y-grip.y,center.y};
+                auto rotated=ks::dragScreenshotMark(shape,ks::MarkPart::Rotation,grip,right,320,240);
+                require(std::abs(rotated.rotation-90)<.01 && rotated.from.x==shape.from.x && rotated.to.y==shape.to.y,
+                        "all native and recognized shapes rotate around their center");
+                auto corner=ks::rotateShapePoint(rotated,rotated.to);
+                require(ks::hitScreenshotMark(rotated,corner,4)==(kind==ks::ScreenshotShape::Triangle?ks::MarkPart::Vertex1:ks::MarkPart::End),"rotated resize handles remain hittable");
+                auto fixed=ks::rotateShapePoint(rotated,rotated.from);
+                auto resized=ks::dragScreenshotMark(rotated,ks::MarkPart::End,corner,{corner.x-15,corner.y+20},320,240);
+                auto stillFixed=ks::rotateShapePoint(resized,resized.from);
+                require(std::abs(stillFixed.x-fixed.x)<=1 && std::abs(stillFixed.y-fixed.y)<=1 && resized.rotation==90,
+                        "resizing rotated shapes keeps the opposite world corner fixed");
+                auto snapped=ks::dragScreenshotMark(shape,ks::MarkPart::Rotation,grip,{center.x+60,center.y-20},320,240,true);
+                require(std::abs(std::remainder(snapped.rotation,15))<.01,"Shift snaps shape rotation to 15 degrees");
+                auto cloned=ks::cloneScreenshotMark(rotated,{rotated},320,240);
+                require(cloned.rotation==rotated.rotation && cloned.shape==kind,"clone preserves shape rotation");
+                auto boundary=ks::shapeOutline(shape).front();
+                std::vector<ks::Mark> linked{shape,{{20,20},boundary,0}};
+                ks::linkScreenshotEndpoint(linked[1],false,boundary,linked,4);
+                require(linked[1].toLink.target!=0,"connector attaches to shape before rotation");
+                linked[0].rotation=90; ks::resolveScreenshotLinks(linked);
+                auto expected=ks::rotateShapePoint(linked[0],boundary);
+                require(std::abs(linked[1].to.x-expected.x)<=1 && std::abs(linked[1].to.y-expected.y)<=1,
+                        "connector follows rotated shape boundary");
+            }
+            ks::Mark shape{{100,90},{200,170},0}; shape.shape=ks::ScreenshotShape::Rectangle;
+            c.marks={shape}; c.selected=0;
+            auto mouse=[&](UINT message,POINT p) {
+                auto x=c.view.left+MulDiv(p.x,c.view.right-c.view.left,c.image->width);
+                auto y=c.view.top+MulDiv(p.y,c.view.bottom-c.view.top,c.image->height);
+                SendMessageW(window,message,message==WM_LBUTTONUP?0:MK_LBUTTON,MAKELPARAM(x,y));
+            };
+            auto grip=ks::screenshotShapeRotationHandle(shape,double(c.unit)*c.image->width/(c.view.right-c.view.left));
+            require(ks::markAt(c,grip).second==ks::MarkPart::Rotation,"shape rotation grip is distinct from thickness grip");
+            mouse(WM_LBUTTONDOWN,grip); mouse(WM_LBUTTONUP,{150+130-grip.y,130});
+            require(std::abs(c.marks[0].rotation-90)<1,"mouse rotation updates selected shape");
+            SendMessageW(window,WM_COMMAND,12,0); require(c.marks[0].rotation==0,"undo restores original shape orientation");
+            SendMessageW(window,WM_COMMAND,18,0); require(std::abs(c.marks[0].rotation-90)<1,"redo restores shape rotation");
+            c.selected=0;
+            ks::Surface rotatedPixels(320,240); PatBlt(rotatedPixels.dc,0,0,320,240,WHITENESS);
+            auto rendered=ks::decodeImage(ks::screenshotClip(rotatedPixels.dc,320,240,c.marks));
+            auto pixel=(100*320+190)*4;
+            require(rendered.bgra[pixel+2]==GetRValue(shape.color) && rendered.bgra[pixel+1]==GetGValue(shape.color),
+                    "export renders rotated shape at its new boundary");
+            POINT center{(c.canvas.left+c.canvas.right)/2,(c.canvas.top+c.canvas.bottom)/2};
+            ks::zoomCanvas(window,c,2,center);
+            grip=ks::screenshotShapeRotationHandle(c.marks[0],double(c.unit)*c.image->width/(c.view.right-c.view.left));
+            require(ks::markAt(c,grip).second==ks::MarkPart::Rotation,"rotation grip works on zoomed canvas");
+            ks::zoomCanvas(window,c,1,center,true);
+            c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
+        }
+        {
+            BYTE savedKeys[256]{},keys[256]{}; GetKeyboardState(savedKeys);
+            std::copy(savedKeys,savedKeys+256,keys); keys[VK_CONTROL]=0x80; SetKeyboardState(keys);
+            auto fit=c.view;
+            SendMessageW(window,WM_KEYDOWN,VK_OEM_PLUS,0);
+            require(c.zoom==1.25 && c.view.right-c.view.left>fit.right-fit.left,"Ctrl+plus zooms canvas");
+            SendMessageW(window,WM_KEYDOWN,VK_SUBTRACT,0);
+            require(std::abs(c.zoom-1)<.001,"Ctrl+numpad minus zooms out");
+            SendMessageW(window,WM_KEYDOWN,VK_ADD,0);
+            SendMessageW(window,WM_KEYDOWN,VK_OEM_MINUS,0);
+            require(std::abs(c.zoom-1)<.001,"both keyboard plus/minus variants work");
+            POINT center{(c.canvas.left+c.canvas.right)/2,(c.canvas.top+c.canvas.bottom)/2};
+            ks::zoomCanvas(window,c,4,center);
+            POINT anchor{center.x+12,center.y+8},screen=anchor; ClientToScreen(window,&screen);
+            auto before=ks::imagePoint(c,anchor,false); double zoom=c.zoom;
+            SendMessageW(window,WM_MOUSEWHEEL,MAKEWPARAM(MK_CONTROL,60),MAKELPARAM(screen.x,screen.y));
+            require(c.zoom==zoom,"partial wheel delta waits for a full step");
+            SendMessageW(window,WM_MOUSEWHEEL,MAKEWPARAM(MK_CONTROL,60),MAKELPARAM(screen.x,screen.y));
+            auto after=ks::imagePoint(c,anchor,false);
+            require(c.zoom>zoom && std::abs(before.x-after.x)<=1 && std::abs(before.y-after.y)<=1,
+                    "Ctrl+wheel zoom keeps image point under cursor");
+            require(!c.history.canUndo(),"zoom does not add image edits to undo history");
+            auto view=c.view;
+            SendMessageW(window,WM_MBUTTONDOWN,MK_MBUTTON,MAKELPARAM(center.x,center.y));
+            SendMessageW(window,WM_MOUSEMOVE,MK_MBUTTON,MAKELPARAM(center.x+15,center.y+10));
+            SendMessageW(window,WM_MBUTTONUP,0,MAKELPARAM(center.x+15,center.y+10));
+            require(c.view.left==view.left+15 && c.view.top==view.top+10 && !c.panning,"middle drag pans enlarged canvas");
+            keys[VK_CONTROL]=0; SetKeyboardState(keys);
+            auto a=ks::imagePoint(c,center),b=ks::imagePoint(c,{center.x+30,center.y+20});
+            SendMessageW(window,WM_LBUTTONDOWN,MK_LBUTTON,MAKELPARAM(center.x,center.y));
+            SendMessageW(window,WM_LBUTTONUP,0,MAKELPARAM(center.x+30,center.y+20));
+            require(c.marks.size()==1 && c.marks[0].from.x==a.x && c.marks[0].to.x==b.x && c.marks[0].to.y==b.y,
+                    "drawing after zoom and pan uses image coordinates");
+            auto original=c.marks[0];
+            keys[VK_CONTROL]=0x80; SetKeyboardState(keys);
+            SendMessageW(window,WM_KEYDOWN,'0',0);
+            require(c.zoom==1 && c.panX==0 && c.panY==0 && c.marks[0].from.x==original.from.x && c.marks[0].to.x==original.to.x,
+                    "Ctrl+0 resets view without transforming annotations");
+            ks::zoomCanvas(window,c,1e6,center); require(c.zoom==16,"zoom has upper bound");
+            ks::zoomCanvas(window,c,1e-6,center); require(c.zoom==.1,"zoom has lower bound");
+            SendMessageW(window,WM_KEYDOWN,'0',0); SetKeyboardState(savedKeys);
+            c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
+        }
         {
             BYTE savedKeys[256]{},keys[256]{}; GetKeyboardState(savedKeys);
             std::copy(savedKeys,savedKeys+256,keys); keys[VK_SHIFT]=0; SetKeyboardState(keys);
@@ -89,6 +254,51 @@ int main(int argc, char **argv)
                 int y=c.view.top+MulDiv(p.y,c.view.bottom-c.view.top,c.image->height);
                 SendMessageW(window,message,(message==WM_LBUTTONUP?0:MK_LBUTTON)|(shift?MK_SHIFT:0),MAKELPARAM(x,y));
             };
+            mouse(WM_LBUTTONDOWN,{30,190});
+            for(int x=35;x<=200;x+=5) mouse(WM_MOUSEMOVE,{x,190+(x%10?2:-2)});
+            auto original=c.stroke.points;
+            mouse(WM_LBUTTONUP,c.stroke.to);
+            require(c.marks.size()==1,"improved stroke is one object");
+            auto improved=c.marks.back().points;
+            SendMessageW(window,WM_COMMAND,12,0);
+            require(c.marks.size()==1 && c.marks.back().points.size()==original.size() &&
+                    std::equal(original.begin(),original.end(),c.marks.back().points.begin(),
+                        [](POINT a,POINT b){return a.x==b.x && a.y==b.y;}),"first undo restores exact raw stroke");
+            SendMessageW(window,WM_COMMAND,12,0);
+            require(c.marks.empty(),"second undo removes stroke");
+            SendMessageW(window,WM_COMMAND,18,0); SendMessageW(window,WM_COMMAND,18,0);
+            require(c.marks.size()==1 && c.marks.back().points.size()==improved.size(),"redo restores improvement");
+            c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
+            mouse(WM_LBUTTONDOWN,{180,120});
+            for(int i=1;i<=120;++i) {
+                double a=i*2*3.141592653589793/120;
+                mouse(WM_MOUSEMOVE,{LONG(std::lround(130+50*std::cos(a))),LONG(std::lround(120+50*std::sin(a)))});
+            }
+            mouse(WM_LBUTTONUP,c.stroke.to);
+            require(c.marks.size()==1 && c.marks[0].shape==ks::ScreenshotShape::Circle &&
+                    !c.marks[0].freehand && !c.marks[0].isHighlight(),"recognized circle is a shape, not a pencil or highlight");
+            auto circle=c.marks[0];
+            require(ks::hitScreenshotMark(circle,circle.to,6)==ks::MarkPart::End,"recognized shape exposes bounding-box resize handle");
+            mouse(WM_LBUTTONDOWN,circle.to);
+            mouse(WM_MOUSEMOVE,{circle.to.x+30,circle.to.y+20});
+            mouse(WM_LBUTTONUP,{circle.to.x+30,circle.to.y+20});
+            require(c.marks[0].to.x>circle.to.x && c.marks[0].to.x-c.marks[0].from.x==c.marks[0].to.y-c.marks[0].from.y &&
+                    c.marks[0].points[0].x>circle.points[0].x,"dragging recognized circle handle scales the whole circle proportionally");
+            SendMessageW(window,WM_COMMAND,12,0);
+            require(c.marks[0].shape==ks::ScreenshotShape::Circle && c.marks[0].to.x==circle.to.x,"undo restores shape size");
+            SendMessageW(window,WM_COMMAND,12,0);
+            require(c.marks[0].freehand && c.marks[0].shape==ks::ScreenshotShape::None,"undo recognition restores editable pencil stroke");
+            SendMessageW(window,WM_COMMAND,18,0);
+            require(c.marks[0].shape==ks::ScreenshotShape::Circle,"redo restores shape type");
+            for(auto kind:{ks::ScreenshotShape::Rectangle,ks::ScreenshotShape::Ellipse,ks::ScreenshotShape::Triangle}) {
+                auto shape=circle; shape.shape=kind;
+                auto resized=ks::dragScreenshotMark(shape,ks::MarkPart::End,shape.to,{shape.to.x+50,shape.to.y+20},320,240);
+                require(resized.points[0].x!=shape.points[0].x && resized.points[24].y!=shape.points[24].y,
+                        "shape resize transforms all outline points in both axes");
+                auto moved=ks::cloneScreenshotMark(resized,{resized},320,240);
+                require(moved.shape==kind && !moved.isHighlight(),"clone preserves recognized shape type");
+            }
+            c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
             mouse(WM_LBUTTONDOWN,{40,40},true);
             mouse(WM_MOUSEMOVE,{100,50},true);
             require(c.stroke.to.x==100 && c.stroke.to.y==40,"Shift constrains pencil horizontally");

tests/stroke_improvement.h

@@ -0,0 +1,96 @@
+#pragma once
+inline void testStrokeImprovement() {
+    auto require=[](bool ok,const char *message){if(!ok) throw std::runtime_error(message);};
+    auto path=[](std::vector<POINT> corners) {
+        std::vector<POINT> p;
+        for(size_t i=1;i<corners.size();++i) for(int j=0;j<25;++j) {
+            double t=j/25.0;
+            p.push_back({LONG(std::lround(corners[i-1].x*(1-t)+corners[i].x*t)),
+                         LONG(std::lround(corners[i-1].y*(1-t)+corners[i].y*t))});
+        }
+        p.push_back(corners.back()); return p;
+    };
+    for(bool tilted:{false,true}) {
+        auto p=path({{40,40},{240,40},{240,140},{40,140},{40,40}});
+        if(tilted) for(auto &q:p) {double x=q.x,y=q.y;q={LONG(std::lround(x*.866-y*.5+100)),LONG(std::lround(x*.5+y*.866))};}
+        for(size_t i=1;i+1<p.size();++i) p[i].y+=int(i%3)-1;
+        auto result=ks::improveScreenshotStroke(p);
+        require(result.size()==5,"recognize noisy and tilted rectangles");
+        double ax=result[1].x-result[0].x,ay=result[1].y-result[0].y;
+        double bx=result[2].x-result[1].x,by=result[2].y-result[1].y;
+        require(std::abs(ax*bx+ay*by)<300,"rectangle has perpendicular sides");
+    }
+    auto triangle=ks::improveScreenshotStroke(path({{130,30},{240,180},{30,180},{130,30}}));
+    for(auto corners:std::vector<std::vector<POINT>>{
+        {{435,172},{455,135},{481,76},{514,78},{567,78},{605,76},{631,103},{652,135},{681,171},{609,172},{539,174},{435,172}},
+        {{531,311},{553,280},{582,235},{616,236},{672,233},{686,264},{693,287},{710,318},{640,314},{531,311}},
+        {{70,40},{160,40},{220,150},{20,150},{70,40}}})
+    for(double angle:{0.0,.6,2.2}) for(bool reverse:{false,true}) {
+        auto p=path(corners);
+        for(auto &q:p) { double x=q.x,y=q.y; q={LONG(std::lround(x*std::cos(angle)-y*std::sin(angle)+700)),
+            LONG(std::lround(x*std::sin(angle)+y*std::cos(angle)+700))}; }
+        if(reverse) std::reverse(p.begin(),p.end());
+        ks::ScreenshotShape kind{}; auto result=ks::improveScreenshotStroke(p,&kind);
+        require(kind==ks::ScreenshotShape::Trapezoid && result.size()==5,"recognize hand-drawn and tilted trapezoids");
+        double ax=result[1].x-result[0].x,ay=result[1].y-result[0].y;
+        double bx=result[3].x-result[2].x,by=result[3].y-result[2].y;
+        require(std::abs(ax*by-ay*bx)/(std::hypot(ax,ay)*std::hypot(bx,by))<.025,"recognized trapezoid bases are parallel");
+    }
+    // Approximate the reported skewed square, including its small closing gap.
+    auto unevenBox=path({{662,297},{663,213},{659,199},{659,181},{691,181},{718,189},
+                        {753,195},{786,195},{775,217},{771,249},{771,289},{766,313},
+                        {745,311},{716,304},{689,300},{671,300}});
+    for(double factor:{.5,1.0,2.5}) for(bool reverse:{false,true}) {
+        auto p=unevenBox;
+        for(auto &q:p) {q.x=LONG(std::lround((q.x-650)*factor+50));q.y=LONG(std::lround((q.y-170)*factor+50));}
+        if(reverse) std::reverse(p.begin(),p.end());
+        ks::ScreenshotShape kind{};
+        auto result=ks::improveScreenshotStroke(p,&kind);
+        require(kind==ks::ScreenshotShape::Rectangle && result.size()==5,"uneven square must not become a circle");
+    }
+    require(triangle.size()==4,"recognize triangle");
+    for(double ry:{50.0,90.0}) {
+        std::vector<POINT> p;
+        for(int i=0;i<=120;++i) {double a=i*2*3.141592653589793/120;
+            p.push_back({LONG(std::lround(150+90*std::cos(a))),LONG(std::lround(150+ry*std::sin(a)))});}
+        auto result=ks::improveScreenshotStroke(p);
+        require(result.size()==97 && result.front().x==result.back().x && result.front().y==result.back().y,
+                "recognize ellipse and circle as closed outlines");
+    }
+    auto open=path({{20,20},{200,20},{200,150},{60,150}});
+    // Hand-traced approximations of the uneven loops in the reported screenshot.
+    for(auto corners:std::vector<std::vector<POINT>>{
+        {{424,408},{449,407},{474,418},{487,439},{488,461},{475,485},{453,488},{432,479},{412,458},{410,435},{416,418},{431,409}},
+        {{352,474},{373,482},{389,501},{392,518},{378,529},{351,531},{331,519},{324,504},{326,486},{339,477},{352,474}},
+        {{246,236},{221,242},{192,256},{166,271},{151,289},{154,303},{172,316},{195,315},{226,305},{246,291},{250,272},{252,252},{246,236}}}) {
+        auto result=ks::improveScreenshotStroke(path(corners));
+        require(result.size()==97,"recognize uneven hand-drawn loops from screenshot");
+    }
+    for(double size:{35.0,100.0,300.0}) for(double aspect:{.5,1.0}) for(int direction:{-1,1}) {
+        std::vector<POINT> p;
+        for(int i=0;i<=120;++i) {
+            double a=direction*(.3+i*5.85/120),r=1+.07*std::sin(3*a)+.035*std::cos(7*a);
+            double x=size*r*std::cos(a),y=size*aspect*r*std::sin(a);
+            p.push_back({LONG(std::lround(500+x*.866-y*.5)),LONG(std::lround(500+x*.5+y*.866))});
+        }
+        require(ks::improveScreenshotStroke(p).size()==97,"recognize wobbly tilted ovals with closing gaps at different sizes");
+    }
+    for(double turns:{.72,1.8}) {
+        std::vector<POINT> p;
+        for(int i=0;i<=120;++i) {double a=i*turns*2*3.141592653589793/120;
+            p.push_back({LONG(std::lround(150+90*std::cos(a))),LONG(std::lround(150+70*std::sin(a)))});}
+        auto result=ks::improveScreenshotStroke(p);
+        require(result.size()!=97,"do not close broad arcs or repeated loops into ovals");
+    }
+    auto smoothed=ks::improveScreenshotStroke(open);
+    require(smoothed.size()>5 && smoothed.front().x==20 && smoothed.back().x==60,"open outline stays open");
+    auto scribble=path({{20,20},{200,150},{200,20},{20,150},{20,20}});
+    require(ks::improveScreenshotStroke(scribble).size()>97,"crossed scribble is not a shape");
+    require(ks::improveScreenshotStroke({{1,1},{1,1},{1,1},{1,1},{1,1}}).empty(),"stationary stroke unchanged");
+    std::vector<POINT> jitter;
+    for(int i=0;i<=100;++i) jitter.push_back({20+i*2,100+(i%2?2:-2)});
+    auto smooth=ks::improveScreenshotStroke(jitter);
+    double deviation=0; for(auto p:smooth) deviation+=std::abs(p.y-100);
+    require(deviation/smooth.size()<1.5 && smooth.front().y==jitter.front().y && smooth.back().y==jitter.back().y,
+            "smoothing reduces jitter and preserves endpoints");
+}