real arrowlength=0.75cm;
real arrowfactor=15;
real arrowangle=15;
real arcarrowfactor=0.5*arrowfactor;
real arcarrowangle=2*arrowangle;
real arrowsizelimit=0.5;
real arrow2sizelimit=1/3;
real arrowdir=5;
real arrowbarb=3;
real arrowhookfactor=1.5;
real arrowtexfactor=1;

real barfactor=arrowfactor;

real arrowsize(pen p=currentpen)
{
 return arrowfactor*linewidth(p);
}

real arcarrowsize(pen p=currentpen)
{
 return arcarrowfactor*linewidth(p);
}

real barsize(pen p=currentpen)
{
 return barfactor*linewidth(p);
}

struct arrowhead
{
 path head(path g, position position=EndPoint, pen p=currentpen,
           real size=0, real angle=arrowangle);
 real size(pen p)=arrowsize;
 real arcsize(pen p)=arcarrowsize;
 filltype defaultfilltype(pen) {return FillDraw;}
}

real[] arrowbasepoints(path base, path left, path right, real default=0)
{
 real[][] Tl=transpose(intersections(left,base));
 real[][] Tr=transpose(intersections(right,base));
 return new real[] {Tl.length > 0 ? Tl[0][0] : default,
     Tr.length > 0 ? Tr[0][0] : default};
}

path arrowbase(path r, pair y, real t, real size)
{
 pair perp=2*size*I*dir(r,t);
 return size == 0 ? y : y+perp--y-perp;
}

arrowhead DefaultHead;
DefaultHead.head=new path(path g, position position=EndPoint, pen p=currentpen,
                         real size=0, real angle=arrowangle) {
 if(size == 0) size=DefaultHead.size(p);
 bool relative=position.relative;
 real position=position.position.x;
 if(relative) position=reltime(g,position);
 path r=subpath(g,position,0);
 pair x=point(r,0);
 real t=arctime(r,size);
 pair y=point(r,t);
 path base=arrowbase(r,y,t,size);
 path left=rotate(-angle,x)*r;
 path right=rotate(angle,x)*r;
 real[] T=arrowbasepoints(base,left,right);
 pair denom=point(right,T[1])-y;
 real factor=denom != 0 ? length((point(left,T[0])-y)/denom) : 1;
 path left=rotate(-angle*factor,x)*r;
 path right=rotate(angle*factor,x)*r;
 real[] T=arrowbasepoints(base,left,right);
 return subpath(left,0,T[0])--subpath(right,T[1],0)&cycle;
};

arrowhead SimpleHead;
SimpleHead.head=new path(path g, position position=EndPoint, pen p=currentpen,
                        real size=0, real angle=arrowangle) {
 if(size == 0) size=SimpleHead.size(p);
 bool relative=position.relative;
 real position=position.position.x;
 if(relative) position=reltime(g,position);
 path r=subpath(g,position,0);
 pair x=point(r,0);
 real t=arctime(r,size);
 path left=rotate(-angle,x)*r;
 path right=rotate(angle,x)*r;
 return subpath(left,t,0)--subpath(right,0,t);
};

arrowhead HookHead(real dir=arrowdir, real barb=arrowbarb)
{
 arrowhead a;
 a.head=new path(path g, position position=EndPoint, pen p=currentpen,
                 real size=0, real angle=arrowangle)
   {
     if(size == 0) size=a.size(p);
     angle=min(angle*arrowhookfactor,45);
     bool relative=position.relative;
     real position=position.position.x;
     if(relative) position=reltime(g,position);
     path r=subpath(g,position,0);
     pair x=point(r,0);
     real t=arctime(r,size);
     pair y=point(r,t);
     path base=arrowbase(r,y,t,size);
     path left=rotate(-angle,x)*r;
     path right=rotate(angle,x)*r;
     real[] T=arrowbasepoints(base,left,right,1);
     pair denom=point(right,T[1])-y;
     real factor=denom != 0 ? length((point(left,T[0])-y)/denom) : 1;
     path left=rotate(-angle*factor,x)*r;
     path right=rotate(angle*factor,x)*r;
     real[] T=arrowbasepoints(base,left,right,1);
     left=subpath(left,0,T[0]);
     right=subpath(right,T[1],0);
     pair pl0=point(left,0), pl1=relpoint(left,1);
     pair pr0=relpoint(right,0), pr1=relpoint(right,1);
     pair M=(pl1+pr0)/2;
     pair v=barb*unit(M-pl0);
     pl1=pl1+v; pr0=pr0+v;
     left=pl0{dir(-dir+degrees(M-pl0,false))}..pl1--M;
     right=M--pr0..pr1{dir(dir+degrees(pr1-M,false))};
     return left--right&cycle;
   };
 return a;
}
arrowhead HookHead=HookHead();

arrowhead TeXHead;
TeXHead.size=new real(pen p)
 {
   static real hcoef=2.1; // 84/40=abs(base-hint)/base_height
   return hcoef*arrowtexfactor*linewidth(p);
 };
TeXHead.arcsize=TeXHead.size;

TeXHead.head=new path(path g, position position=EndPoint, pen p=currentpen,
                     real size=0, real angle=arrowangle) {
 static real wcoef=1/84; // 1/abs(base-hint)
 static path texhead=scale(wcoef)*
 ((0,20)     .. controls (-75,75)    and (-108,158) ..
  (-108,166) .. controls (-108,175)  and (-100,178) ..
  (-93,178)  .. controls (-82,178)   and (-80,173)  ..
  (-77,168)  .. controls (-62,134)   and (-30,61)   ..
  (70,14)    .. controls (82,8)      and (84,7)     ..
  (84,0)     .. controls (84,-7)     and (82,-8)    ..
  (70,-14)   .. controls (-30,-61)   and (-62,-134) ..
  (-77,-168) .. controls (-80,-173)  and (-82,-178) ..
  (-93,-178) .. controls (-100,-178) and (-108,-175)..
  (-108,-166).. controls (-108,-158) and (-75,-75)  ..
  (0,-20)--cycle);
 if(size == 0) size=TeXHead.size(p);
 path gp=scale(size)*texhead;
 bool relative=position.relative;
 real position=position.position.x;
 if(relative) position=reltime(g,position);
 path r=subpath(g,position,0);
 pair y=point(r,arctime(r,size));
 return shift(y)*rotate(degrees(-dir(r,arctime(r,0.5*size)),false))*gp;
};
TeXHead.defaultfilltype=new filltype(pen p) {return Fill(p);};

private real position(position position, real size, path g, bool center)
{
 bool relative=position.relative;
 real position=position.position.x;
 if(relative) {
   position *= arclength(g);
   if(center) position += 0.5*size;
   position=arctime(g,position);
 } else if(center)
   position=arctime(g,arclength(subpath(g,0,position))+0.5*size);
 return position;
}

void drawarrow(frame f, arrowhead arrowhead=DefaultHead,
              path g, pen p=currentpen, real size=0,
              real angle=arrowangle,
              filltype filltype=null,
              position position=EndPoint, bool forwards=true,
              margin margin=NoMargin, bool center=false)
{
 if(size == 0) size=arrowhead.size(p);
 if(filltype == null) filltype=arrowhead.defaultfilltype(p);
 size=min(arrowsizelimit*arclength(g),size);
 real position=position(position,size,g,center);

 g=margin(g,p).g;
 int L=length(g);
 if(!forwards) {
   g=reverse(g);
   position=L-position;
 }
 path r=subpath(g,position,0);
 size=min(arrowsizelimit*arclength(r),size);
 path head=arrowhead.head(g,position,p,size,angle);
 bool endpoint=position > L-sqrtEpsilon;
 if(cyclic(head) && (filltype == NoFill || endpoint)) {
   if(position > 0)
     draw(f,subpath(r,arctime(r,size),length(r)),p);
   if(!endpoint)
     draw(f,subpath(g,position,L),p);
 } else draw(f,g,p);
 filltype.fill(f,head,p+solid);
}

void drawarrow2(frame f, arrowhead arrowhead=DefaultHead,
               path g, pen p=currentpen, real size=0,
               real angle=arrowangle, filltype filltype=null,
               margin margin=NoMargin)
{
 if(size == 0) size=arrowhead.size(p);
 if(filltype == null) filltype=arrowhead.defaultfilltype(p);
 g=margin(g,p).g;
 size=min(arrow2sizelimit*arclength(g),size);

 path r=reverse(g);
 int L=length(g);
 path head=arrowhead.head(g,L,p,size,angle);
 path tail=arrowhead.head(r,L,p,size,angle);
 if(cyclic(head))
   draw(f,subpath(r,arctime(r,size),L-arctime(g,size)),p);
 else draw(f,g,p);
 filltype.fill(f,head,p+solid);
 filltype.fill(f,tail,p+solid);
}

// Add to picture an estimate of the bounding box contribution of arrowhead
// using the local slope at endpoint and ignoring margin.
void addArrow(picture pic, arrowhead arrowhead, path g, pen p, real size,
             real angle, filltype filltype, real position)
{
 if(filltype == null) filltype=arrowhead.defaultfilltype(p);
 pair z=point(g,position);
 path g=z-(size+linewidth(p))*dir(g,position)--z;
 frame f;
 filltype.fill(f,arrowhead.head(g,position,p,size,angle),p);
 pic.addBox(z,z,min(f)-z,max(f)-z);
}

picture arrow(arrowhead arrowhead=DefaultHead,
             path g, pen p=currentpen, real size=0,
             real angle=arrowangle, filltype filltype=null,
             position position=EndPoint, bool forwards=true,
             margin margin=NoMargin, bool center=false)
{
 if(size == 0) size=arrowhead.size(p);
 picture pic;
 pic.add(new void(frame f, transform t) {
     drawarrow(f,arrowhead,t*g,p,size,angle,filltype,position,forwards,margin,
               center);
   });

 pic.addPath(g,p);

 real position=position(position,size,g,center);
 path G;
 if(!forwards) {
   G=reverse(g);
   position=length(g)-position;
 } else G=g;
 addArrow(pic,arrowhead,G,p,size,angle,filltype,position);

 return pic;
}

picture arrow2(arrowhead arrowhead=DefaultHead,
              path g, pen p=currentpen, real size=0,
              real angle=arrowangle, filltype filltype=null,
              margin margin=NoMargin)
{
 if(size == 0) size=arrowhead.size(p);
 picture pic;
 pic.add(new void(frame f, transform t) {
     drawarrow2(f,arrowhead,t*g,p,size,angle,filltype,margin);
   });

 pic.addPath(g,p);

 int L=length(g);
 addArrow(pic,arrowhead,g,p,size,angle,filltype,L);
 addArrow(pic,arrowhead,reverse(g),p,size,angle,filltype,L);

 return pic;
}

void bar(picture pic, pair a, pair d, pen p=currentpen)
{
 picture opic;
 Draw(opic,-0.5d--0.5d,p+solid);
 add(pic,opic,a);
}

picture bar(pair a, pair d, pen p=currentpen)
{
 picture pic;
 bar(pic,a,d,p);
 return pic;
}

using arrowbar=bool(picture, path, pen, margin);

bool Blank(picture, path, pen, margin)
{
 return false;
}

bool None(picture, path, pen, margin)
{
 return true;
}

arrowbar BeginArrow(arrowhead arrowhead=DefaultHead,
                   real size=0, real angle=arrowangle,
                   filltype filltype=null, position position=BeginPoint)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   add(pic,arrow(arrowhead,g,p,size,angle,filltype,position,forwards=false,
                 margin));
   return false;
 };
}

arrowbar Arrow(arrowhead arrowhead=DefaultHead,
              real size=0, real angle=arrowangle,
              filltype filltype=null, position position=EndPoint)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   add(pic,arrow(arrowhead,g,p,size,angle,filltype,position,margin));
   return false;
 };
}

arrowbar EndArrow(arrowhead arrowhead=DefaultHead,
                 real size=0, real angle=arrowangle,
                 filltype filltype=null, position position=EndPoint)=Arrow;

arrowbar MidArrow(arrowhead arrowhead=DefaultHead,
                 real size=0, real angle=arrowangle, filltype filltype=null)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   add(pic,arrow(arrowhead,g,p,size,angle,filltype,MidPoint,margin,
                 center=true));
   return false;
 };
}

arrowbar Arrows(arrowhead arrowhead=DefaultHead,
               real size=0, real angle=arrowangle,
               filltype filltype=null)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   add(pic,arrow2(arrowhead,g,p,size,angle,filltype,margin));
   return false;
 };
}

arrowbar BeginArcArrow(arrowhead arrowhead=DefaultHead,
                      real size=0, real angle=arcarrowangle,
                      filltype filltype=null, position position=BeginPoint)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   real size=size == 0 ? arrowhead.arcsize(p) : size;
   add(pic,arrow(arrowhead,g,p,size,angle,filltype,position,
                 forwards=false,margin));
   return false;
 };
}

arrowbar ArcArrow(arrowhead arrowhead=DefaultHead,
                 real size=0, real angle=arcarrowangle,
                 filltype filltype=null, position position=EndPoint)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   real size=size == 0 ? arrowhead.arcsize(p) : size;
   add(pic,arrow(arrowhead,g,p,size,angle,filltype,position,margin));
   return false;
 };
}

arrowbar EndArcArrow(arrowhead arrowhead=DefaultHead,
                    real size=0, real angle=arcarrowangle,
                    filltype filltype=null,
                    position position=EndPoint)=ArcArrow;

arrowbar MidArcArrow(arrowhead arrowhead=DefaultHead,
                    real size=0, real angle=arcarrowangle,
                    filltype filltype=null)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   real size=size == 0 ? arrowhead.arcsize(p) : size;
   add(pic,arrow(arrowhead,g,p,size,angle,filltype,MidPoint,margin,
                 center=true));
   return false;
 };
}

arrowbar ArcArrows(arrowhead arrowhead=DefaultHead,
                  real size=0, real angle=arcarrowangle,
                  filltype filltype=null)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   real size=size == 0 ? arrowhead.arcsize(p) : size;
   add(pic,arrow2(arrowhead,g,p,size,angle,filltype,margin));
   return false;
 };
}

arrowbar BeginBar(real size=0)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   real size=size == 0 ? barsize(p) : size;
   bar(pic,point(g,0),size*dir(g,0)*I,p);
   return true;
 };
}

arrowbar Bar(real size=0)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   int L=length(g);
   real size=size == 0 ? barsize(p) : size;
   bar(pic,point(g,L),size*dir(g,L)*I,p);
   return true;
 };
}

arrowbar EndBar(real size=0)=Bar;

arrowbar Bars(real size=0)
{
 return new bool(picture pic, path g, pen p, margin margin) {
   real size=size == 0 ? barsize(p) : size;
   BeginBar(size)(pic,g,p,margin);
   EndBar(size)(pic,g,p,margin);
   return true;
 };
}

arrowbar BeginArrow=BeginArrow(),
MidArrow=MidArrow(),
Arrow=Arrow(),
EndArrow=Arrow(),
Arrows=Arrows(),
BeginArcArrow=BeginArcArrow(),
MidArcArrow=MidArcArrow(),
ArcArrow=ArcArrow(),
EndArcArrow=ArcArrow(),
ArcArrows=ArcArrows(),
BeginBar=BeginBar(),
Bar=Bar(),
EndBar=Bar(),
Bars=Bars();

void draw(frame f, path g, pen p=currentpen, arrowbar arrow)
{
 picture pic;
 if(arrow(pic,g,p,NoMargin))
   draw(f,g,p);
 add(f,pic.fit());
}

void draw(picture pic=currentpicture, Label L=null, path g,
         align align=NoAlign, pen p=currentpen, arrowbar arrow=None,
         arrowbar bar=None, margin margin=NoMargin, Label legend=null,
         marker marker=nomarker)
{
 // These if statements are ordered in such a way that the most common case
 // (with just a path and a pen) executes the least bytecode.
 if (marker == nomarker)
   {
     if (arrow == None && bar == None)
       {
         if (margin == NoMargin && size(nib(p)) == 0)
           {
             pic.addExactAbove(
                               new void(frame f, transform t, transform T, pair, pair) {
                                 _draw(f,t*T*g,p);
                               });
             pic.addPath(g,p);

             // Jumping over else clauses takes time, so test if we can return
             // here.
             if (L == null && legend == null)
               return;
           }
         else // With margin or polygonal pen.
           {
             _draw(pic, g, p, margin);
           }
       }
     else /* arrow or bar */
       {
         // Note we are using & instead of && as both arrow and bar need to be
         // called.
         if (arrow(pic, g, p, margin) & bar(pic, g, p, margin))
           _draw(pic, g, p, margin);
       }

     if(L != null && L.s != "") {
       L=L.copy();
       L.align(align);
       L.p(p);
       L.out(pic,g);
     }

     if(legend != null && legend.s != "") {
       legend.p(p);
       pic.legend.push(Legend(legend.s,legend.p,p,marker.f,marker.above));
     }
   }
 else /* marker != nomarker */
   {
     if(marker != nomarker && !marker.above) marker.mark(pic,g);

     // Note we are using & instead of && as both arrow and bar need to be
     // called.
     if ((arrow == None || arrow(pic, g, p, margin)) &
         (bar == None || bar(pic, g, p, margin)))
       {
         _draw(pic, g, p, margin);
       }

     if(L != null && L.s != "") {
       L=L.copy();
       L.align(align);
       L.p(p);
       L.out(pic,g);
     }

     if(legend != null && legend.s != "") {
       legend.p(p);
       pic.legend.push(Legend(legend.s,legend.p,p,marker.f,marker.above));
     }

     if(marker != nomarker && marker.above) marker.mark(pic,g);
   }
}

// Draw a fixed-size line about the user-coordinate 'origin'.
void draw(pair origin, picture pic=currentpicture, Label L=null, path g,
         align align=NoAlign, pen p=currentpen, arrowbar arrow=None,
         arrowbar bar=None, margin margin=NoMargin, Label legend=null,
         marker marker=nomarker)
{
 picture opic;
 draw(opic,L,g,align,p,arrow,bar,margin,legend,marker);
 add(pic,opic,origin);
}

void draw(picture pic=currentpicture, explicit path[] g, pen p=currentpen,
         Label legend=null, marker marker=nomarker)
{
 // This could be optimized to size and draw the entire array as a batch.
 for(int i=0; i < g.length-1; ++i)
   draw(pic,g[i],p,marker);
 if(g.length > 0) draw(pic,g[g.length-1],p,legend,marker);
}

void draw(picture pic=currentpicture, guide[] g, pen p=currentpen,
         Label legend=null, marker marker=nomarker)
{
 draw(pic,(path[]) g,p,legend,marker);
}

void draw(pair origin, picture pic=currentpicture, explicit path[] g,
         pen p=currentpen, Label legend=null, marker marker=nomarker)
{
 picture opic;
 draw(opic,g,p,legend,marker);
 add(pic,opic,origin);
}

void draw(pair origin, picture pic=currentpicture, guide[] g, pen p=currentpen,
         Label legend=null, marker marker=nomarker)
{
 draw(origin,pic,(path[]) g,p,legend,marker);
}

// Align an arrow pointing to b from the direction dir. The arrow is
// 'length' PostScript units long.
void arrow(picture pic=currentpicture, Label L=null, pair b, pair dir,
          real length=arrowlength, align align=NoAlign,
          pen p=currentpen, arrowbar arrow=Arrow, margin margin=EndMargin)
{
 if(L != null && L.s != "") {
   L=L.copy();
   if(L.defaultposition) L.position(0);
   L.align(L.align,dir);
   L.p(p);
 }
 marginT margin=margin(b--b,p); // Extract margin.begin and margin.end
 pair a=(margin.begin+length+margin.end)*unit(dir);
 draw(b,pic,L,a--(0,0),align,p,arrow,margin);
}

// Fit an array of pictures simultaneously using the sizing of picture all.
frame[] fit2(picture[] pictures, picture all)
{
 frame[] out;
 if(!all.empty2()) {
   transform t=all.calculateTransform();
   pair m=all.min(t);
   pair M=all.max(t);
   for(picture pic : pictures) {
     frame f=pic.fit(t);
     draw(f,m,nullpen);
     draw(f,M,nullpen);
     out.push(f);
   }
 }
 return out;
}

// Fit an array of pictures simultaneously using the size of the first picture.
// TODO: Remove unused arguments.
frame[] fit(string prefix="", picture[] pictures, string format="",
           bool view=true, string options="", string script="",
           projection P=currentprojection)
{
 if(pictures.length == 0)
   return new frame[];

 picture all;
 size(all,pictures[0]);
 for(picture pic : pictures)
   add(all,pic);

 return fit2(pictures,all);
}

// Pad a picture to a specified size
frame pad(picture pic=currentpicture, real xsize=pic.xsize,
         real ysize=pic.ysize, filltype filltype=NoFill)
{
 picture P;
 size(P,xsize,ysize,IgnoreAspect);
 draw(P,(0,0),invisible+thin());
 draw(P,(xsize,ysize),invisible+thin());
 add(P,pic.fit(xsize,ysize),(xsize,ysize)/2);
 frame f=P.fit();
 if(filltype != NoFill) {
   frame F;
   filltype.fill(F,box(min(f),max(f)),invisible);
   prepend(f,F);
 }
 return f;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.