#pragma once
inline void testStrokeImprovement() {
    auto require=[](bool ok,const char *message){if(!ok) throw std::runtime_error(message);};
    for(double angle:{0.0,.37,1.57079632679,2.8}) for(bool reverse:{false,true}) {
        std::vector<POINT> p;
        for(int i=0;i<=20;++i) {
            double x=i*10,y=i==0 || i==20?0:(i%3)-1;
            p.push_back({LONG(std::lround(300+x*std::cos(angle)-y*std::sin(angle))),
                         LONG(std::lround(300+x*std::sin(angle)+y*std::cos(angle)))});
        }
        if(reverse) std::reverse(p.begin(),p.end());
        bool line=false; ks::ScreenshotShape shape{};
        auto result=ks::improveScreenshotStroke(p,&shape,&line);
        require(line && shape==ks::ScreenshotShape::None && result.size()==2 &&
                result.front().x==p.front().x && result.front().y==p.front().y &&
                result.back().x==p.back().x && result.back().y==p.back().y,
                "recognize noisy lines at arbitrary angles and preserve directed endpoints");
    }
    for(auto p:std::vector<std::vector<POINT>>{
        {{0,0},{50,1},{100,0}}, {{0,0},{0,0},{50,0},{100,0}}}) {
        bool line=false;
        require(ks::improveScreenshotStroke(p,nullptr,&line).size()==2 && line,
                "recognize sparsely sampled lines and repeated mouse positions");
    }
    for(auto p:std::vector<std::vector<POINT>>{
        {{0,0},{8,1},{16,0}}, {{0,0},{50,0},{40,0},{80,0},{100,0}},
        {{0,0},{25,8},{50,12},{75,8},{100,0}},
        {{0,0},{50,0},{51,10},{52,0},{100,0}}, {{0,0},{0,0},{0,0}}}) {
        bool line=true;
        ks::improveScreenshotStroke(p,nullptr,&line);
        require(!line,"do not straighten short strokes, retracing, curves, spikes or stationary input");
    }
    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");
}