Вы можете использовать Path.getIntersections() или Path.intersects().

Я придумал подход "проб и ошибок": Полный пример

// Returns item.position at the moment of collision
// and the collided object.
function collisionTest(item, curr){
    var prev = item.position;
    var point = curr.clone();
    var hit = null;
    var tolerance = 45;
    var _error = 0.01;
    var firstPass = true;
    var _stopSearching = false;
    var _step = ((curr - prev) / 2).clone();
    var _acceptable_iter_count = 16;
    var _max_iter_count = 100;

    var i; 
    for (i = 0; i < _max_iter_count; i++){
        var _hit = project.hitTest(point, {
            fill: true, 
            stroke: true, 
            segments: true, 
            tolerance: tolerance,
            match: function(hit){
                if (hit.item && hit.item.data && hit.item.data.type === "pointer"){
                    return false
                }
                return true
            }
        })

        if (_hit){
            hit = _hit;
            // hit has happened between prev and curr points 
            // step half way backward
            point -= _step 
            if (_step.length < _error){
                // step is too small, stop trials as soon 
                // as no hit can be found
                _stopSearching = true;
            }
        } else {
            if (firstPass || _stopSearching){
                break;
            } else  {
                // not hit found, but we should 
                // step forward to search for a more 
                // accurate collision point 
                point += _step  
            }
        }
        firstPass = false;
        if (_step.length >= _error * 2 ) {
            _step /= 2
        } else {
            // minimum step length must be error/2
            // in order to save loop count 
            _step = _step.normalize(_error * 0.8)
        }
    }
    if (i > _acceptable_iter_count){
        console.info("found at " + i + ". iteration, step: ", _step.length)
    }
    return {point, hit}
}

Алгоритм

1. Выполните хит-тест.
2. Если обнаружено совпадение, учтите, что фактическое столкновение может произойти где-нибудь между предыдущей позицией и текущей позицией (на delta).
3. Сделайте шаг назад с помощью delta = delta / 2 и выполните проверку нажатия.
4. Если все еще попадает, повторите шаг 3.
5. Если попадание не может быть найдено, сделайте шаг вперед на delta = delta / 2.
6. Если по-прежнему не попадает, повторите шаг 5.
7. В случае попадания повторите шаг 3, если шаг 8 позволяет это сделать.
8. Если размер шага (delta) слишком мал или процесс превышает максимальный предел итераций, разбейте и верните наилучшую возможную точку столкновения (точку для элемента, которая обеспечивает лучшую точку столкновения)

Дальнейшие улучшения

Это решение основано на следующей проблеме: обнаружение попадания - недостаточно, потому что при обнаружении попадания может быть слишком поздно, а фактическое столкновение может произойти где-нибудь между предыдущей и текущей точками (на delta) из-за интервалов обнаружения попаданий.

Этот метод проб и ошибок можно улучшить, начав попытки очень точного «предположения», основанного на правильном вычислении после обнаружения первого попадания.

Мы можем рассчитать 1 (фактическую точку столкновения) за один выстрел, используя 2. Похоже, это ближайшая точка 3 к 4:

Если расчет верен, для обнаружения точки столкновения будет достаточно только двух циклов: 1-й предназначен для обнаружения попадания (как показано #2), а 2-й - для проверки. Если это неверно, то все возьмет на себя метод проб и ошибок.

Вместо того, чтобы пытаться найти прямые пересечения, вы можете вместо этого найти ближайшая точка на пути с позиции движущейся точки.

Если расстояние между точкой и этой ближайшей точкой падает ниже порогового значения (равного strokeWidthPath и радиусу точки), вы можете считать это действительным попаданием.

Хотя есть загвоздка: свойства strokeJoin и strokeCap вашего пути должны быть установлен на round, так как это приводит к симметричной ширине штриха вокруг углы и окончания, поэтому избегайте ложноотрицательных результатов.

Вот пример:

var path = new Path({
    segments: [
        new Point(100, 200),
        new Point(200, 100),
        new Point(300, 300)
    ],
    strokeWidth: 100,
    // This is important.
    strokeJoin: 'round',
    // This is important.
    strokeCap: 'round',
    strokeColor: 'red',
    selected: true,
    position: view.center
})

var dot = new Path.Circle({
    center: view.center,
    radius: 10,
    fillColor: 'red'
})

function onMouseMove(event) {
    dot.position = event.point

    var nearestPoint = path.getNearestPoint(dot.position)
    var distance = dot.position.subtract(nearestPoint)

    if (distance.length < (dot.bounds.width / 2) + (path.strokeWidth / 2)) {
        path.strokeColor = 'blue'
    } else {
        path.strokeColor = 'red'
    }
}

и Эскиз.

При этом лучший способ сделать это - дождаться (или реализовать самостоятельно) Расширение / смещение пути и вместо этого найти пересечение на расширенном пути, поскольку это позволит вам использовать любые настройки strokeJoin / strokeCap.

В идеале расширение / смещение должно выполняться с теми же свойствами strokeJoin / strokeCap, что и Path.

Есть Библиотека JS, которая надежно выполняет смещение полигонов, который может вам пригодиться.