Fix moire pattern

[jorge-ferreira-pii]

Fix #10463

[github-actions]

Welcome to OpenROAD! Thanks for opening your first PR.
Before we review:

• Contribution Guide: https://openroad.readthedocs.io/en/latest/contrib/contributing.html
• Build Instructions: https://openroad.readthedocs.io/en/latest/contrib/BuildWithCMake.html

Please ensure:

• CI passes
• Code is properly formatted
• Tests are included where applicable
  A maintainer will review shortly!

[gemini-code-assist]

Code Review

This pull request introduces sub-pixel Level of Detail (LOD) thresholds and anti-aliasing techniques to the tile generator to prevent Moiré patterns when zooming out on dense regular arrays. Specifically, it collapses sub-pixel instances to single points, skips fine details for small instances, and implements sub-pixel coverage anti-aliasing for drawing borders. The reviewer suggested optimizing the edge-drawing functions (draw_v_edge and draw_h_edge) by avoiding redundant blendPixel calls when the alpha coverage is zero, and caching the result of std::floor in the coverage lambda to improve rendering performance.

[gemini-code-assist]

The current implementation of draw_v_edge and draw_h_edge calls blendPixel twice for every pixel along the edge, even when the sub-pixel coverage alpha (frac_a or 255 - frac_a) is 0. Since blendPixel performs expensive floating-point operations and coordinate transformations, avoiding these redundant calls when the alpha is 0 can significantly improve the rendering performance of the instances-only layer.

Additionally, std::floor(v) is called twice in coverage. We can optimize this by caching the result of std::floor(v).

            auto coverage = [](const double v) {
              const double floor_v = std::floor(v);
              const double frac = v - floor_v;
              return std::make_pair(
                  static_cast<int>(floor_v),
                  static_cast<unsigned char>(std::lround(frac * 255.0)));
            };

            auto draw_v_edge = [&](const double xf) {
              const auto [xi, frac_a] = coverage(xf);
              if (frac_a > 0) {
                Color far_col = gray;
                far_col.a = frac_a;
                for (int iy = loop_yl; iy < loop_yh; ++iy) {
                  blendPixel(image_buffer, xi + 1, 255 - iy, far_col);
                }
              }
              if (frac_a < 255) {
                Color near_col = gray;
                near_col.a = static_cast<unsigned char>(gray.a - frac_a);
                for (int iy = loop_yl; iy < loop_yh; ++iy) {
                  blendPixel(image_buffer, xi, 255 - iy, near_col);
                }
              }
            };

            auto draw_h_edge = [&](const double yf) {
              const auto [yi, frac_a] = coverage(yf);
              if (frac_a > 0) {
                Color far_col = gray;
                far_col.a = frac_a;
                for (int ix = loop_xl; ix < loop_xh; ++ix) {
                  blendPixel(image_buffer, ix, 255 - (yi + 1), far_col);
                }
              }
              if (frac_a < 255) {
                Color near_col = gray;
                near_col.a = static_cast<unsigned char>(gray.a - frac_a);
                for (int ix = loop_xl; ix < loop_xh; ++ix) {
                  blendPixel(image_buffer, ix, 255 - yi, near_col);
                }
              }
            };

[maliberty]

Reduced but I still see

[jorge-ferreira-pii]

• Anti-Moiré Filter (Supersampling & Lanczos-2): The backend now performs supersampling on tiles, followed by decimation and low-pass filtering using a Lanczos-2 filter. This rescales the image to the exact resolution while minimizing moiré noise before PNG conversion.

• Dynamic LOD with Crossfade: For highly dense arrays, a dynamic Level of Detail (LOD) system was implemented to collapse very small instances into unified color blocks. The transition uses a smooth opacity crossfade to eliminate visual pop-in during zooming.

[maliberty]

This sounds good from your description. How does it impact render time? Is the LOD only for instances or all object types?

@gadfort FYI

[jorge-ferreira-pii]

This sounds good from your description. How does it impact render time? Is the LOD only for instances or all object types?

@gadfort FYI

At zoomed-out levels where the LOD is active, there is considerable savings in both time and processing power, as thousands of individual bumps are replaced by simply drawing solid blocks. At more zoomed-in levels where objects are drawn normally, there is a slight increase in backend rendering time due to the 2x supersampling.
The LOD implementation is strictly and specifically applied to instances of the kPhysBump (physical bumps) category, not to all object types.