Offset the open path to one side

[renanfmattos]

Hello,

Is it possible to Offset the open path to one side?
I don't want to inflate the path.

If yes, how can I make it?

Thank you!

[AngusJohnson]

Is it possible to Offset the open path to one side?

Sure, just iterate the path and increment each x by your deltaX.

[renanfmattos]

Dear @AngusJohnson ,

First of all, congratulations on the excellent work and thank you to answer me!

I'm sorry but I wasn't clear, my intention is inflate the open path, like the InflatePaths function does, but I only need one side.

[map-A]

typedef std::pair<double, double> PointD;

// Compute the normal vector between two points
auto getNormal = [](const Point &p1, const Point &p2) -> PointD {
    double dx = p2.x() - p1.x();
    double dy = p2.y() - p1.y();
    double length = geometry::distance(p1, p2);
    return {-dy / length, dx / length};  // Normalized perpendicular vector
};

// Move a point along the normal vector by a given offset
auto movePoint = [](const Point &p, const PointD &normal, double offset) -> PointD {
    return {p.x() + normal.first * offset, p.y() + normal.second * offset};
};

// Find the intersection point of two lines given by their normals and points
auto intersectLines = [](const PointD &p1, const PointD &normal1, const PointD &p2, const PointD &normal2) -> PointD {
    // Calculate determinant to check if lines are parallel
    double det = normal1.first * normal2.second - normal2.first * normal1.second;
    if (std::fabs(det) < eps) return p2;  // Lines are parallel, return second point

    // Solve for intersection point using Cramer's rule
    double x = (normal2.second * (normal1.first * p1.first + normal1.second * p1.second) -
               normal1.second * (normal2.first * p2.first + normal2.second * p2.second)) / det;
    double y = (normal1.first * (normal2.first * p2.first + normal2.second * p2.second) -
               normal2.first * (normal1.first * p1.first + normal1.second * p1.second)) / det;

    return {x, y};
};

int len = (type & CLOSE) && (arr[0] == arr[pcnt - 1]) ? pcnt - 1 : pcnt;
PointArray parallelPoly;
parallelPoly.resize(len);

// Main loop to compute new polygon points
std::vector<PointD> normals(len);  // Cache normals to avoid recalculations
for (int i = 0; i < len; ++i) {
    normals[i] = getNormal(arr[i], arr[(i + 1) % len]);  // Precompute normals for all edges
}

for (int i = 0; i < len; ++i) {
    // Get normals for adjacent edges
    auto normalPrev = normals[ i % len];
    auto normalNext = normals[(i+1)%len];
    
    // Move points along the normals
    PointD newPoint = intersectLines(
        movePoint(arr[i], normalPrev, offset), normalPrev,
        movePoint(arr[(i + 1) % len], normalNext, offset), normalNext
    );

    // Set the new point in the polygon array
    parallelPoly[i].set(newPoint.first, newPoint.second);
}

// Ensure polygon is closed by matching the first and last points
if (type & CLOSE) {
    parallelPoly.append(parallelPoly[0]);
} else {
    auto firstNormal = normals[0];
    auto lastNormal = normals[len - 1];
    PointD firstMovePoint = movePoint(arr[0], firstNormal, offset);
    PointD lastMovePoint = movePoint(arr[len - 1], lastNormal, offset);
    parallelPoly[0].set(firstMovePoint.first, firstMovePoint.second);
    parallelPoly[len - 1].set(lastMovePoint.first, lastMovePoint.second);
}

return parallelPoly;

this may help you.

[AngusJohnson]

No, the library doesn't provide a function to do that. Sorry.

[renanfmattos]

Don't worry, thank you very much for your attention!