Drawing a Mixtillinear Circle With Asymptote

a cubic spline resolved into a fixed path. The implicit initializer for paths is nullpath.

For case, the routine circle(pair c, existent r), which returns a Bezier curve approximating a circle of radius r centered on c, is based on unitcircle (meet unitcircle):

path circle(pair c, existent r) {   render shift(c)*calibration(r)*unitcircle; }        

If high accurateness is needed, a true circle may be produced with the routine Circle defined in the module graph:

import graph; path Circle(pair c, real r, int n=nCircle);        

A circular arc consistent with circle centered on c with radius r from angle1 to angle2 degrees, cartoon counterclockwise if angle2 >= angle1, can exist synthetic with

path arc(pair c, real r, real angle1, real angle2);        

1 may besides specify the direction explicitly:

path arc(pair c, real r, real angle1, existent angle2, bool direction);        

Here the direction tin be specified equally CCW (counter-clockwise) or CW (clockwise). For convenience, an arc centered at c from pair z1 to z2 (assuming |z2-c|=|z1-c|) in the may too be constructed with

path arc(pair c, explicit pair z1, explicit pair z2,          bool management=CCW)        

If high accuracy is needed, true arcs may be produced with routines in the module graph that produce Bezier curves with n control points:

import graph; path Arc(pair c, real r, real angle1, real angle2, bool direction,          int north=nCircle); path Arc(pair c, real r, existent angle1, real angle2, int n=nCircle); path Arc(pair c, explicit pair z1, explicit pair z2,          bool direction=CCW, int n=nCircle);        

An ellipse can exist drawn with the routine

path ellipse(pair c, real a, real b) {   return shift(c)*scale(a,b)*unitcircle; }        

A brace can exist synthetic between pairs a and b with

path brace(pair a, pair b, real amplitude=bracedefaultratio*length(b-a));        

This instance illustrates the use of all five guide connectors discussed in Tutorial and Bezier curves:

size(300,0); pair[] z=new pair[10];  z[0]=(0,100); z[ane]=(fifty,0); z[2]=(180,0);  for(int n=3; n <= nine; ++n)   z[due north]=z[n-3]+(200,0);  path p=z[0]..z[1]---z[2]::{upwards}z[iii] &z[3]..z[4]--z[5]::{upward}z[6] &z[6]::z[7]---z[eight]..{up}z[9];  draw(p,grey+linewidth(4mm));  dot(z);        

Here are some useful functions for paths:

int length(path p);

This is the number of (linear or cubic) segments in path p. If p is cyclic, this is the same equally the number of nodes in p.

int size(path p);

This is the number of nodes in the path p. If p is circadian, this is the same as length(p).

bool cyclic(path p);

returns true iff path p is circadian.

bool straight(path p, int i);

returns true iff the segment of path p between node i and node i+1 is straight.

bool piecewisestraight(path p)

returns true iff the path p is piecewise straight.

pair bespeak(path p, int t);

If p is circadian, return the coordinates of node t mod length(p). Otherwise, return the coordinates of node t, unless t < 0 (in which case betoken(0) is returned) or t > length(p) (in which example point(length(p)) is returned).

pair point(path p, real t);

This returns the coordinates of the bespeak betwixt node floor(t) and floor(t)+1 respective to the cubic spline parameter t-flooring(t) (see Bezier curves). If t lies exterior the range [0,length(p)], information technology is first reduced modulo length(p) in the example where p is cyclic or else converted to the respective endpoint of p.

pair dir(path p, int t, int sign=0, bool normalize=true);

If sign < 0, return the direction (as a pair) of the incoming tangent to path p at node t; if sign > 0, return the management of the approachable tangent. If sign=0, the mean of these ii directions is returned.

pair dir(path p, real t, bool normalize=true);

returns the direction of the tangent to path p at the point between node floor(t) and floor(t)+1 respective to the cubic spline parameter t-floor(t) (come across Bezier curves).

pair dir(path p)

returns dir(p,length(p)).

pair dir(path p, path q)

returns unit(dir(p)+dir(q)).

pair accel(path p, int t, int sign=0);

If sign < 0, render the acceleration of the incoming path p at node t; if sign > 0, return the dispatch of the outgoing path. If sign=0, the hateful of these two accelerations is returned.

pair accel(path p, real t);

returns the acceleration of the path p at the point t.

real radius(path p, real t);

returns the radius of curvature of the path p at the point t.

pair precontrol(path p, int t);

returns the precontrol point of p at node t.

pair precontrol(path p, existent t);

returns the effective precontrol point of p at parameter t.

pair postcontrol(path p, int t);

returns the postcontrol point of p at node t.

pair postcontrol(path p, real t);

returns the effective postcontrol signal of p at parameter t.

real arclength(path p);

returns the length (in user coordinates) of the piecewise linear or cubic curve that path p represents.

real arctime(path p, existent Fifty);

returns the path "time", a real number betwixt 0 and the length of the path in the sense of point(path p, real t), at which the cumulative arclength (measured from the outset of the path) equals L.

pair arcpoint(path p, real L);

returns point(p,arctime(p,L)).

real dirtime(path p, pair z);

returns the first "time", a real number betwixt 0 and the length of the path in the sense of point(path, real), at which the tangent to the path has the direction of pair z, or -1 if this never happens.

existent reltime(path p, real l);

returns the time on path p at the relative fraction l of its arclength.

pair relpoint(path p, real l);

returns the signal on path p at the relative fraction l of its arclength.

pair midpoint(path p);

returns the point on path p at half of its arclength.

path reverse(path p);

returns a path running backwards along p.

path subpath(path p, int a, int b);

returns the subpath of p running from node a to node b. If a > b, the direction of the subpath is reversed.

path subpath(path p, existent a, real b);

returns the subpath of p running from path time a to path fourth dimension b, in the sense of signal(path, real). If a > b, the direction of the subpath is reversed.

real[] intersect(path p, path q, real fuzz=-i);

If p and q have at least one intersection point, return a real assortment of length 2 containing the times representing the respective path times along p and q, in the sense of point(path, real), for 1 such intersection signal (equally chosen by the algorithm described on page 137 of The MetaFontbook). The computations are performed to the absolute error specified by fuzz, or if fuzz < 0, to car precision. If the paths practise non intersect, return a existent array of length 0.

real[][] intersections(path p, path q, real fuzz=-ane);

Return all (unless there are infinitely many) intersection times of paths p and q as a sorted array of real arrays of length 2 (see sort). The computations are performed to the absolute error specified by fuzz, or if fuzz < 0, to machine precision.

real[] intersections(path p, explicit pair a, explicit pair b, real fuzz=-1);

Return all (unless there are infinitely many) intersection times of path p with the (infinite) line through points a and b every bit a sorted array. The intersections returned are guaranteed to be correct to inside the absolute mistake specified by fuzz, or if fuzz < 0, to machine precision.

real[] times(path p, real x)

returns all intersection times of path p with the vertical line through (x,0).

real[] times(path p, explicit pair z)

returns all intersection times of path p with the horizontal line through (0,z.y).

real[] mintimes(path p)

returns an assortment of length 2 containing times at which path p reaches its minimal horizontal and vertical extents, respectively.

real[] maxtimes(path p)

returns an assortment of length 2 containing times at which path p reaches its maximal horizontal and vertical extents, respectively.

pair intersectionpoint(path p, path q, real fuzz=-1);

returns the intersection point betoken(p,intersect(p,q,fuzz)[0]).

pair[] intersectionpoints(path p, path q, real fuzz=-1);

returns an array containing all intersection points of the paths p and q.

pair extension(pair P, pair Q, pair p, pair q);

returns the intersection point of the extensions of the line segments P--Q and p--q, or if the lines are parallel, (infinity,infinity).

piece cut(path p, path knife, int north);

returns the portions of path p before and after the nth intersection of p with path pocketknife as a structure piece (if no intersection exist is constitute, the entire path is considered to exist 'before' the intersection):

struct slice {   path earlier,later on; }            

The argument n is treated as modulo the number of intersections.

slice firstcut(path p, path pocketknife);

equivalent to cutting(p,knife,0); Note that firstcut.afterwards plays the role of the MetaPost cutbefore command.

piece lastcut(path p, path knife);

equivalent to cut(p,knife,-1); Note that lastcut.before plays the office of the MetaPost cutafter command.

path buildcycle(... path[] p);

This returns the path surrounding a region divisional past a list of ii or more than consecutively intersecting paths, following the behaviour of the MetaPost buildcycle command.

pair min(path p);

returns the pair (left,bottom) for the path bounding box of path p.

pair max(path p);

returns the pair (right,meridian) for the path bounding box of path p.

int windingnumber(path p, pair z);

returns the winding number of the cyclic path p relative to the point z. The winding number is positive if the path encircles z in the counterclockwise direction. If z lies on p the abiding undefined (divers to be the largest odd integer) is returned.

bool interior(int windingnumber, pen fillrule)

returns true if windingnumber corresponds to an interior bespeak according to fillrule.

bool inside(path p, pair z, pen fillrule=currentpen);

returns true iff the betoken z lies inside or on the border of the region bounded by the circadian path p according to the fill rule fillrule (see fillrule).

int inside(path p, path q, pen fillrule=currentpen);

returns 1 if the cyclic path p strictly contains q according to the make full rule fillrule (encounter fillrule), -1 if the circadian path q strictly contains p, and 0 otherwise.

pair inside(path p, pen fillrule=currentpen);

returns an capricious point strictly inside a cyclic path p co-ordinate to the fill dominion fillrule (see fillrule).

path[] strokepath(path g, pen p=currentpen);

returns the path assortment that PostScript would fill in drawing path grand with pen p.

an unresolved cubic spline (list of cubic-spline nodes and command points). The implicit initializer for a guide is nullpath; this is useful for building up a guide inside a loop.

A guide is similar to a path except that the computation of the cubic spline is deferred until drawing time (when it is resolved into a path); this allows two guides with gratis endpoint weather to be joined together smoothly. The solid curve in the post-obit example is built up incrementally as a guide, but merely resolved at drawing time; the dashed bend is incrementally resolved at each iteration, earlier the entire fix of nodes (shown in red) is known:

size(200);  real mexican(real 10) {return (1-8x^ii)*exp(-(4x^two));}  int n=30; real a=1.5; real width=2a/n;  guide hat; path solved;  for(int i=0; i < north; ++i) {   real t=-a+i*width;   pair z=(t,mexican(t));   hat=hat..z;   solved=solved..z; }  describe(lid); dot(hat,red); depict(solved,dashed);        

Nosotros indicate out an efficiency distinction in the use of guides and paths:

guide g; for(int i=0; i < 10; ++i)   grand=g--(i,i); path p=grand;        

runs in linear time, whereas

path p; for(int i=0; i < 10; ++i)   p=p--(i,i);        

runs in quadratic time, as the entire path up to that point is copied at each step of the iteration.

The following routines tin can be used to examine the individual elements of a guide without actually resolving the guide to a fixed path (except for internal cycles, which are resolved):

int size(guide chiliad);

Analogous to size(path p).

int length(guide g);

Coordinating to length(path p).

bool circadian(path p);

Analogous to circadian(path p).

pair point(guide m, int t);

Analogous to point(path p, int t).

guide contrary(guide g);

Coordinating to reverse(path p). If yard is cyclic and as well contains a secondary cycle, it is first solved to a path, then reversed. If g is non cyclic merely contains an internal cycle, only the internal cycle is solved before reversal. If at that place are no internal cycles, the guide is reversed but not solved to a path.

pair[] dirSpecifier(guide g, int i);

This returns a pair array of length two containing the outgoing (in element 0) and incoming (in element 1) direction specifiers (or (0,0) if none specified) for the segment of guide g betwixt nodes i and i+1.

pair[] controlSpecifier(guide g, int i);

If the segment of guide 1000 between nodes i and i+1 has explicit outgoing and incoming control points, they are returned as elements 0 and 1, respectively, of a two-element array. Otherwise, an empty assortment is returned.

tensionSpecifier tensionSpecifier(guide g, int i);

This returns the tension specifier for the segment of guide yard betwixt nodes i and i+1. The private components of the tensionSpecifier type tin can be accessed as the virtual members in, out, and atLeast.

real[] curlSpecifier(guide chiliad);

This returns an assortment containing the initial curl specifier (in chemical element 0) and final curl specifier (in element 1) for guide k.

As a technical item nosotros notation that a management specifier given to nullpath modifies the node on the other side: the guides

a..{upward}nullpath..b; c..nullpath{up}..d; e..{up}nullpath{down}..f;        

are respectively equivalent to

a..nullpath..{upwardly}b; c{upward}..nullpath..d; e{down}..nullpath..{up}f;        

gentileconstainey.blogspot.com

Source: https://asymptote.sourceforge.io/doc/Paths-and-guides.html

Share :