Offset with square option vs Clipper 1

[Jonathan-Granier]

Hello
I noticed a small difference on the option "JoinType.Square" in the offset algorithm between Clipper1 and Clipper2 :

Clipper 1	Clipper 2

The joins are not "cutted" if the angle >= 90

I think it is not a bug because it is documented but there is way to have the previous result in Clipper2 ?

[AngusJohnson]

Hi Jonathan.
I'm not really committed to either option (but not both, at least not without very good reason).
And I'd be happy to be persuaded by a consensus of users.
But I'm curious, why does this matter to you?

[Jonathan-Granier]

Thanks for quick answer

I think the result of Clipper2 can be obtains with Mitter + the good mitter limit. So with Clipper 1 philosophy you have more possibility. Like a square with cuted join.

If I take illustrator as example, the bevel mode of offset work as Clipper1

[AngusJohnson]

In Clipper.Offset.cs and inside ClipperOffset.OffsetPoint() change to the following ...

else //convex
{
  if (_joinType == JoinType.Round)
    DoRound(group, path, j, k, Math.Atan2(sinA, cosA));
  // else miter when the angle isn't too acute (and hence exceed ML)
  else if (_joinType == JoinType.Miter && cosA > _tmpLimit - 1)
    DoMiter(group, path, j, k, cosA);
  // don't square angles that deviate < ~15 degrees
  else if (_joinType == JoinType.Square && Math.Abs(sinA) > 0.25)
    DoSquare(group, path, j, k);
  else
    // don't square shallow angles that are safe to miter
    DoMiter(group, path, j, k, cosA);
}

[Jonathan-Granier]

With this change in mitter mode, you can not have Square join if the mitter is exceeded.
And why add a threshold on the angle value ?

I think a code like this cover each use case and it is the same as clipper 1

else //convex
{
  if (_joinType == JoinType.Round)
    DoRound(group, path, j, k, Math.Atan2(sinA, cosA));
  // else miter when the angle isn't too acute (and hence exceed ML)
  else if (_joinType == JoinType.Miter && cosA > _tmpLimit - 1)
    DoMiter(group, path, j, k, cosA);
  else
    DoSquare(group, path, j, k);
}

Clipper1 :

 else
    switch (jointype)
    {
      case jtMiter:
        {
          double r = 1 + (m_normals[j].X * m_normals[k].X +
            m_normals[j].Y * m_normals[k].Y);
          if (r >= m_miterLim) DoMiter(j, k, r); else DoSquare(j, k);
          break;
        }
      case jtSquare: DoSquare(j, k); break;
      case jtRound: DoRound(j, k); break;
    }

[AngusJohnson]

With this change in mitter mode, you can not have Square join if the mitter is exceeded.

Indeed, you're correct.

And why add a threshold on the angle value ?

Because mitering is much faster than squaring, and mitering is indistinguishable from squaring when the angle of deviation is small. And empirically, that angle seems to be at about 15%.

      else //convex
      {
        if (_joinType == JoinType.Round)
          DoRound(group, path, j, k, Math.Atan2(sinA, cosA));
        else if (_joinType == JoinType.Miter)
        {
          // miter unless the angle is so acute the miter would exceeds ML
          if (cosA > _tmpLimit - 1) DoMiter(group, path, j, k, cosA);
          else DoSquare(group, path, j, k);
        }
        // don't bother squaring angles that deviate < ~20 degrees because
        // squaring will be indistinguishable from mitering and just be a lot slower
        else if (cosA > 0.9)
          DoMiter(group, path, j, k, cosA); 
        else
          DoSquare(group, path, j, k);
      }

[Jonathan-Granier]

Seem to be fair ! I agree with you, with a small deviation squared or miter is same result
Thanks for your consideration about that !

[Jonathan-Granier]

To be sure, you will make a fix on it ?