Squiggly line in Asymptote

Question

A somewhat similar question to this one, but in a different language for graphics:

Is there a simple way to draw a squiggly line in asymptote?

Answer 1

It seems that there has not been such a module for squiggly lines, although it is possible (and not very hard) to define one.

A simple implementation:

path zigzag(path g, real step=2, real distance=2)
{
    real len = arclength(g);
    int state = 0;
    path zig;
    for (real u = 0; u < len; u += step) {
        real t = arctime(g, u);
        pair p = point(g, t);
        pair norm = unit(rotate(90) * dir(g, t));
        if (state == 1)
            p = p + distance * norm;
        else if (state == 3)
            p = p - distance * norm;
        zig = zig -- p;
        state = (state + 1) % 4;
    }
    zig = zig -- point(g, length(g));
    return zig;
}

// test
path g = (0,0) -- (2cm,0) -- (4cm,1cm) -- (0,3cm) -- cycle;
draw(zigzag(g));

Answer 2

Leo Liu's answer above led me to the following implementation (I wanted more smooth squiggly lines):

guide squiggly(path g, real stepsize, real slope=45)
{
        real len = arclength(g);
        real step = len / round(len / stepsize);
        guide squig;
        for (real u = 0; u < len; u += step){
                real a = arctime(g, u);
                real b = arctime(g, u + step / 2);
                pair p = point(g, a);
                pair q = point(g, b);
                pair np = unit( rotate(slope) * dir(g,a));
                pair nq = unit( rotate(0 - slope) * dir(g,b));
                squig = squig .. p{np} .. q{nq};
        }
        squig = squig .. point(g, length(g)){unit(rotate(slope)*dir(g,length(g)))};
        return squig;
}

The funny definition of step from stepsize is so that the endpoints of the curve will not be distorted, and that when applying to a closed (smooth) curve the object will actually close smoothly.

For piecewise smooth curves it is perhaps better to apply squiggly to each of the smooth components separately.