Draw Line Arrowhead Without Rotating in Canvas

Question

Most code to drawing arrowheads in html canvas involves rotating the canvas context and drawing the lines.

My use case is to draw them using trigonometry without rotating the canvas. or is that vector algorithm you call it? Help is appreciated.

This is what I have (forgot where I got most of the code). Draws 2 arrowheads on start and end based on the last 2 parameters arrowStart and arrowEnd which are boolean.

drawLineArrowhead: function(context, arrowStart, arrowEnd) {

        // Place start end points here.
        var x1 = 0;
        var y1 = 0;
        var x2 = 0;
        var y2 = 0;

        var distanceFromLine = 6;
        var arrowLength = 9;
        var dx = x2 - x1;
        var dy = y2 - y1;
        var angle = Math.atan2(dy, dx);
        var length = Math.sqrt(dx * dx + dy * dy);

        context.translate(x1, y1);
        context.rotate(angle);
        context.beginPath();
        context.moveTo(0, 0);
        context.lineTo(length, 0);

        if (arrowStart) {
            context.moveTo(arrowLength, -distanceFromLine);
            context.lineTo(0, 0);
            context.lineTo(arrowLength, distanceFromLine);
        }

        if (arrowEnd) {
            context.moveTo(length - arrowLength, -distanceFromLine);
            context.lineTo(length, 0);
            context.lineTo(length - arrowLength, distanceFromLine);
        }

        context.stroke();
        context.setTransform(1, 0, 0, 1, 0, 0);
    },

Answer 1

See the code below, just a bit of trigonometry.

canvas = document.getElementById("canvas");
ctx = canvas.getContext("2d");
ctx.lineCap = "round";
ctx.lineWidth = 5;

function drawLineArrowhead(p1, p2, startSize, endSize) {
  ctx.beginPath()
  ctx.moveTo(p1.x, p1.y);
  ctx.lineTo(p2.x, p2.y);
  
  if (startSize > 0) {
    lineAngle = Math.atan2(p2.y - p1.y, p2.x - p1.x);
    delta = Math.PI/6  
    for (i=0; i<2; i++) {
      ctx.moveTo(p1.x, p1.y);
      x = p1.x + startSize * Math.cos(lineAngle + delta)
      y = p1.y + startSize * Math.sin(lineAngle + delta)
      ctx.lineTo(x, y);
      delta *= -1
    }
  }
  if (endSize > 0) {
    lineAngle = Math.atan2(p1.y - p2.y, p1.x - p2.x);
    delta = Math.PI/6  
    for (i=0; i<2; i++) {
      ctx.moveTo(p2.x, p2.y);
      x = p2.x + endSize * Math.cos(lineAngle + delta)
      y = p2.y + endSize * Math.sin(lineAngle + delta)
      ctx.lineTo(x, y);
      delta *= -1
    }
  }
  ctx.stroke();
}

drawLineArrowhead({x:10, y:10}, {x:100, y:20}, 0, 30)
drawLineArrowhead({x:20, y:25}, {x:140, y:120}, 20, 20)
drawLineArrowhead({x:140, y:20}, {x:80, y:50} , 20, 0)

drawLineArrowhead({x:150, y:20}, {x:150, y:90}, 20, 5)
drawLineArrowhead({x:180, y:90}, {x:180, y:20}, 20, 5)

drawLineArrowhead({x:200, y:10}, {x:200, y:140}, 10, 10)
drawLineArrowhead({x:220, y:140}, {x:220, y:10}, 10, 20)

<canvas id="canvas">

If you run it you should see a few samples.
The drawLineArrowhead has 4 parameters (p1, p2, startSize, endSize) the first two are the starting-point and end-point of the line, the last two are arrow size, just to give some control to the final user over how big are those arrows at the end, if we want to remove them we set to 0.