diff --git a/extern/agg24-svn/include/agg_image_filters.h b/extern/agg24-svn/include/agg_image_filters.h index 8e1bc8f0dba4..e5b813dfc8a6 100644 --- a/extern/agg24-svn/include/agg_image_filters.h +++ b/extern/agg24-svn/include/agg_image_filters.h @@ -53,8 +53,13 @@ namespace agg double r = filter.radius(); realloc_lut(r); unsigned i; +#ifndef MPL_FIX_AGG_IMAGE_FILTER_LUT_BUGS unsigned pivot = diameter() << (image_subpixel_shift - 1); for(i = 0; i < pivot; i++) +#else + unsigned pivot = (diameter() << (image_subpixel_shift - 1)) - 1; + for(i = 0; i < pivot + 1; i++) +#endif { double x = double(i) / double(image_subpixel_scale); double y = filter.calc_weight(x); @@ -62,7 +67,11 @@ namespace agg m_weight_array[pivot - i] = (int16)iround(y * image_filter_scale); } unsigned end = (diameter() << image_subpixel_shift) - 1; +#ifndef MPL_FIX_AGG_IMAGE_FILTER_LUT_BUGS m_weight_array[0] = m_weight_array[end]; +#else + m_weight_array[end] = (int16)iround(filter.calc_weight(diameter() / 2) * image_filter_scale); +#endif if(normalization) { normalize(); diff --git a/extern/agg24-svn/include/agg_span_interpolator_linear.h b/extern/agg24-svn/include/agg_span_interpolator_linear.h index ef10505ce11a..39cc7610b00c 100644 --- a/extern/agg24-svn/include/agg_span_interpolator_linear.h +++ b/extern/agg24-svn/include/agg_span_interpolator_linear.h @@ -53,6 +53,10 @@ namespace agg //---------------------------------------------------------------- void begin(double x, double y, unsigned len) { +#ifdef MPL_FIX_AGG_INTERPOLATION_ENDPOINT_BUG + len -= 1; +#endif + double tx; double ty; @@ -75,6 +79,10 @@ namespace agg //---------------------------------------------------------------- void resynchronize(double xe, double ye, unsigned len) { +#ifdef MPL_FIX_AGG_INTERPOLATION_ENDPOINT_BUG + len -= 1; +#endif + m_trans->transform(&xe, &ye); m_li_x = dda2_line_interpolator(m_li_x.y(), iround(xe * subpixel_scale), len); m_li_y = dda2_line_interpolator(m_li_y.y(), iround(ye * subpixel_scale), len); diff --git a/extern/agg24-svn/src/agg_image_filters.cpp b/extern/agg24-svn/src/agg_image_filters.cpp index 549d9adbf5af..1571308be55a 100644 --- a/extern/agg24-svn/src/agg_image_filters.cpp +++ b/extern/agg24-svn/src/agg_image_filters.cpp @@ -88,6 +88,7 @@ namespace agg } } +#ifndef MPL_FIX_AGG_IMAGE_FILTER_LUT_BUGS unsigned pivot = m_diameter << (image_subpixel_shift - 1); for(i = 0; i < pivot; i++) @@ -96,6 +97,7 @@ namespace agg } unsigned end = (diameter() << image_subpixel_shift) - 1; m_weight_array[0] = m_weight_array[end]; +#endif } diff --git a/lib/matplotlib/tests/baseline_images/test_axes/imshow.pdf b/lib/matplotlib/tests/baseline_images/test_axes/imshow.pdf index 183b072fc312..64f4e3519717 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_axes/imshow.pdf and b/lib/matplotlib/tests/baseline_images/test_axes/imshow.pdf differ diff --git a/lib/matplotlib/tests/baseline_images/test_axes/imshow.png b/lib/matplotlib/tests/baseline_images/test_axes/imshow.png index c19c4e069b15..d709d9f03f47 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_axes/imshow.png and b/lib/matplotlib/tests/baseline_images/test_axes/imshow.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_axes/imshow.svg b/lib/matplotlib/tests/baseline_images/test_axes/imshow.svg index 3931a1fce23f..b0bcc2358e3a 100644 --- a/lib/matplotlib/tests/baseline_images/test_axes/imshow.svg +++ b/lib/matplotlib/tests/baseline_images/test_axes/imshow.svg @@ -1,12 +1,23 @@ - - + + + + + + 2025-09-29T14:55:05.029228 + image/svg+xml + + + Matplotlib v3.11.0.dev1393+gfd8d60293, https://matplotlib.org/ + + + + + - + @@ -15,7 +26,7 @@ L 460.8 345.6 L 460.8 0 L 0 0 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> @@ -24,50 +35,50 @@ L 369.216 307.584 L 369.216 41.472 L 103.104 41.472 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> - - + + - +" style="stroke: #000000; stroke-width: 0.8"/> - + - + - + - + - + @@ -76,40 +87,40 @@ L 0 3.5 - +" style="stroke: #000000; stroke-width: 0.8"/> - + - + - + - + - + @@ -117,28 +128,28 @@ L -3.5 0 +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> - - + + diff --git a/lib/matplotlib/tests/baseline_images/test_axes/imshow_clip.png b/lib/matplotlib/tests/baseline_images/test_axes/imshow_clip.png index cde64b03c7f6..d6cdbd5c07f1 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_axes/imshow_clip.png and b/lib/matplotlib/tests/baseline_images/test_axes/imshow_clip.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_axes/imshow_clip.svg b/lib/matplotlib/tests/baseline_images/test_axes/imshow_clip.svg index d1169e860808..d92dfd8613de 100644 --- a/lib/matplotlib/tests/baseline_images/test_axes/imshow_clip.svg +++ b/lib/matplotlib/tests/baseline_images/test_axes/imshow_clip.svg @@ -1,23 +1,23 @@ - + - + - 2021-03-02T20:09:49.859581 + 2025-09-29T14:55:05.618523 image/svg+xml - Matplotlib v3.3.4.post2495+g8432e3164, https://matplotlib.org/ + Matplotlib v3.11.0.dev1393+gfd8d60293, https://matplotlib.org/ - + @@ -26,7 +26,7 @@ L 460.8 345.6 L 460.8 0 L 0 0 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> @@ -35,29 +35,29 @@ L 369.216 307.584 L 369.216 41.472 L 103.104 41.472 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> - - + + - +" style="stroke: #000000; stroke-width: 0.8"/> - + - + - +" transform="scale(0.015625)"/> @@ -86,14 +86,14 @@ z - + - + - +" transform="scale(0.015625)"/> - + - + - + - +" transform="scale(0.015625)"/> - + - + - + - +" transform="scale(0.015625)"/> - + - + - + - +" transform="scale(0.015625)"/> - + @@ -264,17 +264,17 @@ z - +" style="stroke: #000000; stroke-width: 0.8"/> - + - + @@ -282,62 +282,62 @@ L -3.5 0 - + - + - + - + - + - + - + - + - + - + - + - + - - + +" clip-path="url(#p94ac23f9ea)" style="fill: none; stroke: #440154; stroke-width: 1.5"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> - + - - + + diff --git a/lib/matplotlib/tests/baseline_images/test_axes/use_colorizer_keyword.png b/lib/matplotlib/tests/baseline_images/test_axes/use_colorizer_keyword.png index c1c8074ed80c..9d6f8b9c6f63 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_axes/use_colorizer_keyword.png and b/lib/matplotlib/tests/baseline_images/test_axes/use_colorizer_keyword.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_colors/light_source_shading_topo.png b/lib/matplotlib/tests/baseline_images/test_colors/light_source_shading_topo.png index 222ebca02d82..dbfb1d425665 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_colors/light_source_shading_topo.png and b/lib/matplotlib/tests/baseline_images/test_colors/light_source_shading_topo.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_colors/test_norm_abc.png b/lib/matplotlib/tests/baseline_images/test_colors/test_norm_abc.png index 077365674ac2..7f621591e000 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_colors/test_norm_abc.png and b/lib/matplotlib/tests/baseline_images/test_colors/test_norm_abc.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.pdf b/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.pdf index e0baa115a6b3..ad7f762c7a0b 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.pdf and b/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.pdf differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.png b/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.png index c593b2163997..eef9639a3324 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.png and b/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.svg b/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.svg index 406a278f2f3f..1e93d3be191b 100644 --- a/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.svg +++ b/lib/matplotlib/tests/baseline_images/test_image/bbox_image_inverted.svg @@ -1,12 +1,23 @@ - - + + + + + + 2025-09-29T15:01:35.415119 + image/svg+xml + + + Matplotlib v3.11.0.dev1393+gfd8d60293, https://matplotlib.org/ + + + + + - + @@ -15,7 +26,7 @@ L 460.8 345.6 L 460.8 0 L 0 0 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> @@ -24,57 +35,57 @@ L 414.72 307.584 L 414.72 41.472 L 57.6 41.472 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> - - + + - +" style="stroke: #000000; stroke-width: 0.8"/> - + - + - + - + - + - + @@ -83,47 +94,47 @@ L 0 3.5 - +" style="stroke: #000000; stroke-width: 0.8"/> - + - + - + - + - + - + @@ -131,22 +142,22 @@ L -3.5 0 +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> diff --git a/lib/matplotlib/tests/baseline_images/test_image/downsampling.png b/lib/matplotlib/tests/baseline_images/test_image/downsampling.png index 4e68e52d787b..358e5ef2d88f 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/downsampling.png and b/lib/matplotlib/tests/baseline_images/test_image/downsampling.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/image_cliprect.png b/lib/matplotlib/tests/baseline_images/test_image/image_cliprect.png index 4552df3515cd..be33cdd70a99 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/image_cliprect.png and b/lib/matplotlib/tests/baseline_images/test_image/image_cliprect.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/image_cliprect.svg b/lib/matplotlib/tests/baseline_images/test_image/image_cliprect.svg index f8d96c2e312b..50fe1d126a74 100644 --- a/lib/matplotlib/tests/baseline_images/test_image/image_cliprect.svg +++ b/lib/matplotlib/tests/baseline_images/test_image/image_cliprect.svg @@ -1,12 +1,23 @@ - - + + + + + + 2025-10-08T04:51:13.682947 + image/svg+xml + + + Matplotlib v3.11.0.dev1425+gb39ccbe8f, https://matplotlib.org/ + + + + + - + @@ -15,7 +26,7 @@ L 460.8 345.6 L 460.8 0 L 0 0 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> @@ -24,236 +35,240 @@ L 369.216 307.584 L 369.216 41.472 L 103.104 41.472 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> - - + + - +" style="stroke: #000000; stroke-width: 0.8"/> - + - - + + - - - +" transform="scale(0.015625)"/> + + - + - - + + - - - +" transform="scale(0.015625)"/> + + - + - - + + - - - +" transform="scale(0.015625)"/> + + - + - - + + - - - +" transform="scale(0.015625)"/> + + - + - - + + - - - +" transform="scale(0.015625)"/> + + - + - - + + - - - +" transform="scale(0.015625)"/> + + @@ -262,83 +277,83 @@ z - +" style="stroke: #000000; stroke-width: 0.8"/> - + - - + + - + - - + + - + - - + + - + - - + + - + - - + + - + - - + + @@ -346,28 +361,28 @@ L -3.5 0 +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/> - - + + diff --git a/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.pdf b/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.pdf index e7d205bfa8e0..8a09bd6a5a56 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.pdf and b/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.pdf differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.png b/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.png index c9e9f343c5db..3ba3c6e53116 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.png and b/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.svg b/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.svg index 7f1678715ba3..d977b05b0253 100644 --- a/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.svg +++ b/lib/matplotlib/tests/baseline_images/test_image/image_composite_alpha.svg @@ -1,12 +1,23 @@ - - + + + + + + 2025-07-10T19:29:50.453941 + image/svg+xml + + + Matplotlib v3.11.0.dev1075+g945334b731, https://matplotlib.org/ + + + + + - + @@ -15,7 +26,7 @@ L 576 432 L 576 0 L 0 0 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> @@ -24,112 +35,112 @@ L 468 388.8 L 468 43.2 L 122.4 43.2 z -" style="fill:#008000;"/> +" style="fill: #008000"/> - - + + +" style="fill: none; stroke: #000000; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-linejoin: miter; stroke-linecap: square"/> - +" style="stroke: #000000; stroke-width: 0.5"/> - + - +" style="stroke: #000000; stroke-width: 0.5"/> - + - + - + - + - + - + - + - + - + - + - + @@ -138,82 +149,82 @@ L 0 4 - +" style="stroke: #000000; stroke-width: 0.5"/> - + - +" style="stroke: #000000; stroke-width: 0.5"/> - + - + - + - + - + - + - + - + - + - + - + @@ -221,8 +232,8 @@ L -4 0 - - + + diff --git a/lib/matplotlib/tests/baseline_images/test_image/imshow_bignumbers.png b/lib/matplotlib/tests/baseline_images/test_image/imshow_bignumbers.png index ec189bb949e5..2b13a801e1c8 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/imshow_bignumbers.png and b/lib/matplotlib/tests/baseline_images/test_image/imshow_bignumbers.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/imshow_bignumbers_real.png b/lib/matplotlib/tests/baseline_images/test_image/imshow_bignumbers_real.png index ce3404488ebb..8de0a4e34204 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/imshow_bignumbers_real.png and b/lib/matplotlib/tests/baseline_images/test_image/imshow_bignumbers_real.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.pdf b/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.pdf index 0342a2baa4b2..d93b352994ab 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.pdf and b/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.pdf differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.png b/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.png index 9e68784cff4f..0fadbb4b1cc4 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.png and b/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.svg b/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.svg index c0385c18467c..e6638ad21189 100644 --- a/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.svg +++ b/lib/matplotlib/tests/baseline_images/test_image/imshow_masked_interpolation.svg @@ -6,11 +6,11 @@ - 2024-04-23T11:45:45.434641 + 2025-09-29T15:01:41.159575 image/svg+xml - Matplotlib v3.9.0.dev1543+gdd88cca65b.d20240423, https://matplotlib.org/ + Matplotlib v3.11.0.dev1393+gfd8d60293, https://matplotlib.org/ @@ -29,167 +29,167 @@ z " style="fill: #ffffff"/> - + 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" id="imageaf5fd25eb2" transform="scale(1 -1) translate(0 -51.12)" x="57.6" y="-54.994689" width="51.12" height="51.12"/> - + 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" id="image4cd56d3e07" transform="scale(1 -1) translate(0 -51.12)" x="118.820571" y="-54.994689" width="51.12" height="51.12"/> - + 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" id="image4a7ce4b4ad" transform="scale(1 -1) translate(0 -51.12)" x="180.041143" y="-54.994689" width="51.12" height="51.12"/> - + +iVBORw0KGgoAAAANSUhEUgAAAEcAAABHCAYAAABVsFofAAAMpElEQVR4nOWca4wk11XHf/fW7e6Z7plZ787MZmbt3eza60es3QRj56WAxUqJ5aBIWCiBIEDYQSCBAvlgS8hSAh8SQZ5G8CECS+QTkRIRECiAEqMoQcEhBmcThySw9no9O+N9eGd31jsz/ajqW/fyoR5dVX2rp3t2Z3oRR6rp7rqn7vnf/z3n3HOrq0e8urJgyYgnBEWRfWdiXRy6jutLdUt6dmNw60pHv1Ef/fpy8bRTt0zE2QI5AF6J8v834pSfoSa5pJvrqPe+a22fLkDLCjq2R2lDaOqip5sOqOT6nL10QCY9N3fb+T7gOynB+dsBUNlBJSLJMJZ561uPuowGPu/VaJkuJ4Npnlk/znOrh1lrTbKv3ubt80u8d+aH3FvdYFZO0rYBq6HOEZ23l5UMqdsf33VJ2wYAqKZVTgWPfLQ1bRUPAwbmVcjkgbO0Xj3AUjDPV18+Bj+YYfKSZXV2L1+9f4pD917hvtqLVA6coX3uNlrWo2Oi4daFztsSfZHtxLBb0rIhAOIbZ+5yIpDC9J1riICOVTRNjdVwhob0eaB2kUMHL/bpnltZ4GQwR9PUaEifeW+DhtC4PBXcRMiYtPve+OrwI7sBcnp5AQDVtNW+Rg+bC6e69DmsNpmTVZ5pz/DJlx5m7YV5vKObnHr/HzkN3HrwIu/7xw+x/uNZ6ve8zqeO/R33TlwDDKe6ksSuR/8kuDDsprTiCVRNU+uBKUjHVgCYlm0OqSnk4mmaLy6y/ux+jv7lKS5+4K6BRjrfmePOL5xm+dGjLN01x8/f8WMA6mcPsKL3Re+Fn+p7Dm8dhyTerTqm0tdYzAGr4Qwvdl+jvrJAp1lBH99k5bG72bwnGGgkON5i+dGj+G9pIYXl0quLtKxlTU8A0DQ1pMwQkjE7TqISr1at2HOk6F+hGtLHw/Dsxp188uLDrK3X+ez9X+H0L/9hqioG+L79ld7ydHLpICee/y0mq13ee9tPuL/+CtOyTWI/wuAmarclcRiVhE4RzLTsMO+t07EVnls9jPjrOW4/tcHhv13blsGfPrzC4s9U2Tg0wzcfvYsHj/4PDRGwZGqUYZAl+WinpWWjCVOtsJZrSNzZw9KxFVqmRjOosOeyRr58fatG5cxFJidvZbU1SdPUQEZ5rWkKGMZESiIJHtUy1Xx8x7PXMlXWdAOADx75Hvd+/hwNEfClq2/jF/7i95n/rsfacYt9vKSyAw5//jPMPi+5/NaQ97/jP/nYLf9E01ZZCuY55S/SCmvUvUxCdi7nu09UGla+6S8CpbCsBQ2eXTnCZC3g++/747TtN//st1n+yOMsp2eeKDVy9nef4CzAF+DffvVzfO6LfxO3nOLBf3mCtdYk7zywxMGJq/0Yxph0kjyo2mGvzsnO0vLmXnhhho1GHuQdX26ztA2D//HFx8kSuXzqDUxc8lia3mC20sxgGGMmjqUT7xqcngNwuVVn5ozBvyW/8/nGdz56QwBMnvfYc8Zw8f5pWrdUnXlmXEQleVi1w3ydk3iPDj1qGqTeGYDCgAwtOpQEhQkaZ0hBlG8BZCdUdEJFYDwC49EJK3TCClUVsn5Y0rw1f+FD97m3C6NKZ97w+h0ejYmAdlihHVbwQ4UfqvRzcuy2+EbhG4UqzhpEMzdV87l8j49UeXd/+Zf2wPdHN/iuRz4Df9/7rA41ac5WeUPNxw/di8K4JJkQ5eseMJEBVPM0d78x2m0/8u3fYcLTTHpdjrbPwpc+gV6dQM4G/OBdt/FTjl3zuZUFjv77x+muTiL3+dQXVvmNJx9Ljd+jL6Uh3MmQczMk5HZYwRMWFRj3LYSap1msr+OHiu8+fzdv+pNX+PKFp/noDx/haz/356le6fbhINjMbcpvvXKUE0de4uHFD/PfTx7hxNt/xKTX5Xx7hk5YKSVlHGQl0aSCME9OMhwpLNeCaIOIsoSLc7z70ge5Ekxty+BSMMdDMx/CLBwEZVPX7YQVuo4JGmdS7ug4rIKSsApCjyTkavtbvPTr06hffBtmfXtbiH++8mZefvJudMNS29/ktfY0UliyYQ03R1gl0aR06L5zL4SlHVSoeCHzM5vsf+sF9lbbPHfhEG/+yFMsfmuNyw/sxf5V+fbhLb/3FIvfvMKFE7N0X7vGQ+85STussNzcy4ZfI9AeVRWm9ooyLqKSBUJ2Q4/soY1EGxm91x5tv0oQeuytttlXbaK1x9x/dXjmhY8z/+3XBhqZP9nk6z/6BPMnmwS+Yra6yb5qVA03/WpsJzoC7aWHDqMj0IpAu4vUnRRfK3ytUFpLSr5OSmezFVR46do8NW8vYSi58I4Jfnby05y7cwFeLDdy/sEGD858mgvHGnhqg+9dPYQfKq4062nf3UzOc8EYh/doE0WTMq6wSgFFcLWWXPB7xZh/vMXymySe6nL8Hz7Gkb1rHNtznrnKBpe70/xkfYFXrs4StJosH5N4XoAHnLk86wTjCqlkwsJtD3H7Eug454QZcpweFAM3OtKTytCo+0xN+LT8KtdW9nDxK3vo/muFry3/KQ8vfpi1E0e49k7LLYdfZ6oWsOlX2WzVMEkse+GW3jpOST3Hhj2UOVii702kEwparRp+EA3UKsu1OzyCqYM80HyKC1O3094vsLUum60anaCC1hKThI+wGNPvrc55GRNROvEcqwtAB3gPRIWd0aB9DyFATIR0Dho6i7KnpyxCGbSv0Mm9rBKyEwKGmZjdEh1zIg49/SlbiqMMm2tGS3WHvJ7BYT2sPae3leoOtqcwDo0tJ6ygMDJZ7uv7enHqlvWb9NFTKMtrTnsOb1VCC4eCC2RebI6QLfoYhewRPcUZggPJLuqW9WtRIixHbge4nRhmRrdF9nX061IYhWyR/6AKDzzklLK61sX6UEZcfWR1b16ye2G1hWE3UUXdwblnS7JHSeplOG4g2ar0a6EBnRWbbFFhCMM3G9kuDErqrZVuzECHux76yT7zB4+XdLozcuSpzwJJWJWRPSTDka67XNoxsndQkkVKCdfObpRZ3sKdbzTZuyEJJ0pmyBlplq43pOLzQ5G9y5KSk/WcrWYZBhNYLGh3jOwdFhmv4MMlZOgDn9UrLipW0O8VIy3HAy/ZcUlqv14ROGKY5JoK5IiYnIEzfxN5SlGcYdVrzb30nc9KbkCpW7nVh/XKMlu7JTJNyNkHBbaRZ5ACJFgZ6QkLwhARVNibjkz2mERoQJR5DriX44JnAFjPYpKRZ9pFaMlV39sIMwBbet9h56S3lBc3niN6jzAREVb2rs16jrC9a903lwbbGvS06k5JwkkvrEpJEf3NGS8QJnqGR4YgjMVKgVFglMiHmmtFK8qYV6lERBiBzRWBWUkH37cUxfnFEwgT/Sapuh5SWQ+QvsZUFd09VYIZDz0R5SNs9KBSr28xVPIdX50Tvarik1t2wOwJS+oZQoKwFs83VNc6qPNr2GYLr1FH6n2EtUnCqsRKEYdeHG4ic69lC1LG5UEJOVJqGwGPD6kzR5g5dKIT65voVQYWrxlgrq3z9bWnMVdfR7YCZGBTUmRo49CLX+MwzNnS5Rh2WxIcSmh36PRJrNL7RZBAhjbKM55A1Kq8Z+LXEBONKGyMRXZtHFL0cpIQcWKO7/OOsEndLUmiKRdWA28vJJFgSB92TFYjU6/ize/Dm5nG1iqYqfjnQt1eohZh1IeI/kSrGw4Oxp2NyRSBQveKkRwu6UZpRZw7Mj/M1PUKpuZBaMETGC/+6tjPLFPFgrAYLs4lfTxMOT0H6IEsrC755kybBFMRhDUVNdqkSraIbqYKHEB2n6Tlw3i+DpbdhJx4ANsFaT0RPV4tIq2UGB3lI2GjPJN+l1TwBnee2SLUd1jSOkeEETn53bFjn1BaIQtEKLDaZipkC6HNPMmSJCzhJtrxFIyz+NwlScNKdLN3u0oAOWLfucqUhA4usrMXhv264wopANk1WCHyCblPnKS4CRS2EDaSbZOdRzqGjae2CGzBc9LWIUmRUPw9h0jPOwY1AtlpqI2jCIwdRtHNbMtdS6eTlPhTGfAsMSXL8c1ISgohIUfo4TwHon0V4MwRQ/XRVxIkaDKfhul7hyWJpq09JwNcDAI+aCCucLrJCMlJGlba8ZhFGUDpevJ0BM+BlOyBRG91fodFxA6jbLdbaCkDKulLBCUridgipPJ9jED4LklCjnho5rH+B6C2CK+8smNwW9Y7W1xf0ocTV1m/LtJLMbj7VTZw/MuF6zVWonu9pNsy/YHePpw9F7YeOZmOchtoJ5jtzXbORUcJJ4duqRdtE2+KLb+i2r6werf4gLuzEcLiRpKa1909Up3kDBIncaO4Nf93iPtfESQ00SuQEzUAAAAASUVORK5CYII=" id="image91d0d5f5b0" transform="scale(1 -1) translate(0 -51.12)" x="241.261714" y="-54.994689" width="51.12" height="51.12"/> - + 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" id="imagea49606cabe" transform="scale(1 -1) translate(0 -51.12)" x="302.482286" y="-54.994689" width="51.12" height="51.12"/> - + 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" id="imagecc5128dabe" transform="scale(1 -1) translate(0 -51.12)" x="363.702857" y="-54.994689" width="51.12" height="51.12"/> - + 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" id="image30ab40c936" transform="scale(1 -1) translate(0 -51.12)" x="57.6" y="-148.916571" width="51.12" height="51.12"/> - + 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" id="image3f235855ab" transform="scale(1 -1) translate(0 -51.12)" x="118.820571" y="-148.916571" width="51.12" height="51.12"/> - + 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" id="imagea8929fed79" transform="scale(1 -1) translate(0 -51.12)" x="180.041143" y="-148.916571" width="51.12" height="51.12"/> - + +iVBORw0KGgoAAAANSUhEUgAAAEcAAABHCAYAAABVsFofAAAI10lEQVR4nO1cPY8lORU9dvl1j3aAXSHBgrQSORLS/gM+0v0jhAhyotVmhJvwO0j3N4BEQAZCTEACi6ZnZ3tePfsSVNUr2/dcl/16GJJ10v1uHd97fH0/XPWq2/3tHz8QrMNDj4nIAGByTsnY/EWHxgKAJzpMLNHOOFhYb+idnMXaXs83A0CIsn+I688pc3LKwLknoywT88ja55e7lCBq/qajjpQrttIRETVWNl5eYxUHjk0SV7mOrPAg4fphWolBSpCvBQAmp2VXHVJeM9PNaWNXbKWepffugFjIPZm/6CClwEhNAAgP6a5SwBftXSoFYmNruTccaeno3gxzPh9MhzeoAUCYs8gBgFg7AcCEhCh675LhnFrHJDaDWod3gkh2OBk64kBUMx2tohse5ZQBE1A5YXIJMwnqCYK5NrQ5pdYB5vCFqNJBsDn+SLbo4NjaloldnRtepmf9ZEhULQbI4g0sTwMDO6Ijx0qOtTfG1LFeDq/TfQdJXaiZUWagRYYtvuAgbWyhN/t1xNmWDgAIUfasi1UGbspSNckjIaJOvwWU61uMJ0V1c2BdxyZIg0MpXziAYhW3ddUjOgAgPFRp1d2t0IoelvP9u3kYwQd6GdcF21EqMkh4FXXNYUWKKmqQGXPyu9uQkboZZtKi9wmlwVkmpfy3P/mDOf/TP39CdmZSi966iHISxU4GFvjVj78wuQDA53/5Kbb1Wmev3KHhMZ3Mi/nYlOXOtHZhG7NMV3yBzXTkG3B1koXN5KZDG+NRTuouwHI+AISvLvewBgtr87RLxsvLM4rv2bVD7MHGsJGXkJ7SEb6OJwriixoj9CZp3SMOH6kvPZv2Ot617blUFuS5br1ua3vlEd5DkKr6dEQo173rrXRA9FFha9/g9mKFn5AUX85nWm5PyHzGLTxWkWMtmIXhkXPyqLTud6zwHolcS7fmczcUueH15Y5eMAkOFMBX8/1QCozYG6l92/gq7mvt0RvmuIeSu2Ehf/r7R/j4Ry/U9X+++CEuf50AaRHp30Ull3EHzUkfW+ijmFWv+9kXv1YWRlLrFofeastKq6dGp2UvPF4CgS6DlbhRo092nhF172JTwuO8O8cTbzASLeUjpJ/q/BFuIxGzjSBZC6xbnHMC1C3dbVinsUCB31uvga2JOtHY9ac6WlButj06H0CC5ruNoiAfke/daWs+u8ai1cb2R6vJzbDFsOF83tOKGbEeznOsRb5vflNOZCPOsh1ozw+S9quSUzh0lMvkQmSUC8XeqiNPlWLxuZzMz52a97+aQzCP3eKUYqlJXOWOOnMxqCTGLrqBCGM6+HymI4nBoVpzSOe15jDwQErZWCbsTx2zfr2VFG5jg1w2RJ5SnM8mL0wdpB/Hdti6Ej3Gml9aDhRk5sCAVMEd6FepcKLlDqqdgovW+fpCK7Kkxhs7rb6r23CqpZOlWbbAnGMOu67wfDAElQ5pYi0qu46tifREz/W3w8ayjODOx7uzy/uw0qxJnfYoBzsty/Q9ms+x9dXg4jFZM00oAUD1uYMaVtpqRCcjMuTcTtk6QvEsm9UbK5uMOB51pFZrVV1mi9RBA2s6t/HUI7j54NBlH4MIVjicKObzuS0rmvVJDENHkqNICr7+PrQiYCnlNZQ4oXc+n25ysM9anRth2CucYzzgXwkYk/nhkmJHSgJ7BcfuQv1OMB1ZieuyEnxdkI+MPamdGzJsaUKwVk2pF2apHuiytTz4syZJsawVD9WjPkJtHXxjTMd22tts1ZdC/Vg2B3R8FUQnGgdUbsSQ8ebCV2GUGptD5WSLr3JODiI3vrZxlta9KWGkz1upeQO3PDU2+LkEbPMLZWSMYN+GjqMoPtJxFMVsfuEcU8kNxg5lA7b+H/YA0srt1qk/jhA2T/6dhN+1PQAIfv3KYWwXnb48ELZDUYDbUvhWezlWpVWfMiGyUR3jWGm8it8bESO8gr/oyT1nhpECd0sxZPYcbWlj3OpLLYeH2l7Rzow2Xbc9lwC3vWTjAPEO26s5rEW29NKnjTUvQ8cff/8btMbHv/wdWUftgP3XMM1SgOlo7I5LwOnrhNNDhD8npJPH/J0J83s+c5Ch+IlhP3RIBeCqLGkdHgEg+LkvVC0yPgL3/5px9+LfkIdXcN96Dv/RdyHfv0c8ke39Xzmkw1HT2cYxvVm3snqf/ljcf0XB9HiB/Ocl4pdfYrpcMH3vfbgo8N7qgqWQ6R3h0Dtc/X6d07/mfggubhcFYv19DT3jrO08Ail4TM/fwxQj3PPnkMmtdcg6n+z1Seu1OGiHDqcVezyjOGTfW9G0sgwXMrn+kDuP+OEHcB98G+k0IT4LcBfhf+jFUqVrU/LaeBzlbExnvim73vJz8DN/2kWdY7wSEU8e6f1ncCIQt3Qql4TeeL6Nk+vobcA2/OXIOVV0/vwXn0kL0DJuhjVxYm+6NPFDhXtgHUbkBldFDn36TyaLo4+3F+PVW1BNLGpsdqngMOZwdmA0H2sYz9GDPzeesFeE8t3oOUWPPOelEWTs6EjNGcOWn4OLjdvy66l37UzoODAWDtXHBPtWobS12OfEHcMWHAgWx46qrwZXvwgIIUqEGN1+qbBJSNtt3PmrdOHnLl60DSclq/BrbjsPLQrufFFCc+FoFDqWAnSBVgEmWLPFs5UPFHaj69YcAs7ZM4sOoy3HmYbtV66U3qc4/6l6dVoVR+qqc3gH9U3bZsSS6/d1ld6rA4kOfZe86S3FQvVuF5+qdxkBc5VW2c4XLW4glGk65hF1pLfDXnHVk4WOcDP0Bnl8Uxoo9AwQ90aBoI9UB1LSwt+6MQPcAtLqbvr9FSNlOMFrBUPOBbSDm49Fq2sNB/AbzmOHB8TGIZA5wvq3IfSLMsuRRpTWXFrOqR1pv0XA7Xe8tbCnVQ8By5iFhXU7QhwJGJsxkmqDm3GgN6Q3xDmGEWcStRelHv3eUK96sL2bsHFVcUOwgYaXbE/AHBVrZ0TtOAMry5/YVdi4mutwRjS4Mfx6rCj1ZqnLOmjG95t/aNYY/wXFra+GFssPrgAAAABJRU5ErkJggg==" id="image7599b6a708" transform="scale(1 -1) translate(0 -51.12)" x="241.261714" y="-148.916571" width="51.12" height="51.12"/> - + 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" id="image1e3120a578" transform="scale(1 -1) translate(0 -51.12)" x="302.482286" y="-148.916571" width="51.12" height="51.12"/> - + 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" id="image6e1531e8f6" transform="scale(1 -1) translate(0 -51.12)" x="363.702857" y="-148.916571" width="51.12" height="51.12"/> - + +iVBORw0KGgoAAAANSUhEUgAAAEcAAABHCAYAAABVsFofAAADFklEQVR4nO2bMW4TQRSGd9bjSAiJAoHENSgiUSLBERBVDkBJ4TvQRFyAEqWCM9AiIQpOQBCUFFYUR4BCvBSWnHlvPZ/fGHf5/2p35t8349/vfzPrXafTHw+GrkBfHE+6OiYpmfO+wlvFSdW+vohDvNUY16P48Wu81XmdO0n1mdNnuvGQOACJA8hfL++Yhj4t18eTbun5RZ8pVeY64vrrbAzbN+ZeXXMhzmRrnGJMc129T3CQOID87fJetbN3tvLpavrAgtaqZAcbw49PXLZOMX7Q/qvrhCokDkDiAPLpn/vVTr9ckl9LLvJaasV/cO11y4IXr5vKHIDEAeTvv+6aBtp5linp0/jN4dv18YvPR/UYDTvr8Y45xn398J3pm315Vo1BNlPmACQOQOIA0tMPL43pEnnQ1Jz43TXXsdgy2zJmtG768UdcnM0Nh8QB5J8Xt01DMtapX+jtRykftSr/vB63dcvcyI7KHIDEAUgcQD5f3DINxq/oa38e4zJvcOdValucehhb80ZbEKEKiQPIfy+m9V6fupSfZV+DHXcdb2Qr5MIYEEKZA5A4AIkDyP0C3sJxJhyi9SJam7ZwB6gro8qx7d5jzYM7fz0rj0PiACQOIOeFvw8Adun5ES9tPKQYXbehdtBcsD6VvHhdoTqqzAFIHECeNtgKl3KIwVuA2NhtcerEUQw91NsNEgcgcQB5eu5agjVg7N0G7g7jjeLsaW5lffLXKXMAEgeQD87hzrdlp7vzzroecy9WbeAODf8EuvGQOACJA8gHi/r7KS3e/fh+tj5+9PwYYrZs7ethiPvpZGa6Do+ON/K2xVTmACQOID1+8ir8lAuXxL6+07Qxbef+lnZ6qlfwKB1kqzgkDkDiAPL07Ldt4Zdi1ofR+uMxqg17q09FJ3zlLeMrcwASB5An8wvTMPD7tZuPidd1297ZjcXsnCVwSY7PjbYAyhyAxAFIHEAe5me2pY/WFacr1JUUrQE9f1cpWp/8XKLj65fAOCQOIF/N5/XeBlslXK4Lbov9yGZoKze3qAXdZ1LmACQOQOIA/gFzjLJEhG9/CQAAAABJRU5ErkJggg==" id="image71ded072da" transform="scale(1 -1) translate(0 -51.12)" x="57.6" y="-242.838454" width="51.12" height="51.12"/> - + +iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAABsklEQVR4nI2UMY7UQBBF36/uFUgzntEEJETADVaCG5CTbIiIOQCChCvABQgJCTfaEGlDAsQ1IAEJobFZN4Hb7mrbsyJozfevX69K457RU10kACSGT0NWNFlLAjOqrNngw5CTEcPhkB9OQEaAh1UQVX7UYU8yLcPSqp8kyOwqm3W8OWxmBcr0ESCWdQf2mdjt7+YAFSytQpga07QEJCt1a/eR+fl89YZ2F6bTNUW3TeC4C7Q74/ryNced0TbDOTYBPX7xLlXb3aLLdqeyIraNluGVxpP1GTx2zQrgP7erwcN1jt02LaZMDaPH7RDfF/9ulyaqhxTIzMflsxf77c0JSP2LRMld15KVzwIxbrocKACt6hlw9PI8U0JKxGb7BylhLmyuYQq7Rl83lzES8d7md9U4Dwy6r/xlPWHqAYj3Nz8XhQ9PPvLyy/PBo4RNiUDR788/8errBYEyUG+/PUtjYxgbvVZPcJt6DVSwQE98eOd7hvQEV5gDgnos+8GD6afhgUR8cPYjNxbTXCC4r6NAxiHegyCIj85+DQ/5LQZp+v8M+d2alLUwjJDvj2FYzgQNXf8AXD2vrUvE87wAAAAASUVORK5CYII=" id="image8c6ddab5e9" transform="matrix(2.550857 0 0 2.550857 118.820571 242.941311)" style="image-rendering:crisp-edges;image-rendering:pixelated" width="20" height="20"/> - + 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" id="imaged4b3b72061" transform="scale(1 -1) translate(0 -51.12)" x="180.041143" y="-242.838454" width="51.12" height="51.12"/> - + +iVBORw0KGgoAAAANSUhEUgAAAEcAAABHCAYAAABVsFofAAAL70lEQVR4nNVce4xdRRn/fXPm7gMKlPCw2LLdIttQak0NSFEUm1CgwYiBgA8iJb6iJhJMm1rEIKAReZRWND5iNCo+QtCAgRhAMYZHwjOANuVV1rSFFiyhlC77uPfMzOcfM2fOa87du9vuPcuXTPbM+5vffN/vmzP33qW9u+YzChKBikUQEKWyiMrtqtqKwJh2jEDb414Otu22yDGjS4XhRevykjkMJACIwBjBthwAc9fAlIC35YH5DhB4GZcmAeYveC1Xds6p1+AfT10LAOCCEoSS4Xmpart6cC3u3b45V/fWrvkAUgBNZtgj5r/abg0HXZKp6aWd80qrGxp4PZfPAnAwwAnV7Xn1OP9ctLCjF+yunGMmZGL3IggQ5D7Tg6jNArslI1lTcfpEYc+acXnHNAEAYsT0YZ/p92k/9+K3L56Ohb+6ESds2ojLHv8CGOTT719agZVn/xAExtJvbcrVFdPQ9beAwFj1ke/jZ89/PFd31b8vwOCPN2Lhr2/AL144E2+bhk8jLDHCEvuMTd2WfcZghA3o3uElJbP56oOXYecXN/h81gWW3HkNXrjw2mBdUbJudNJVm/H89Wt9fvXQety/7SYAwND3NuO2Nbfm+mat+bTBnR0s6eDJ8zuti8sx7vWFAsYqtrdR2XHszUOmNeHhO0wunwADAHN2MsZMLwSZYrdaZIIjAIDYr/uwX/dh1PRixPRjxPRj8ak7fMPF1+ajyhnv3za9CT+zL5df+JON/rlx0R7sN30YCaQx04tuy4jpwYjpAf38hTNLbvW1kx7K5bsRrW7fdop/LgaITw89XTnHTMi9w0sQkYFsmmoX6qZMZPSIqN7oOcENRDCQY6anVkUSKbqPqBGghP/kiO4DAEQZMrzk0S/jmXtORt+bjPi8feBPpS7wlScvxfbTxvEA/xkrz7oB/M/qaLXiko144k/rAAAXPPJ18EfTtivu24CJe96D1hHA0k+8iA+Z7cHzVh0kPeo2itY+c3FJo00fvCOXz/JDkWM6DeWTjXPdlk/m8iJTf/Wyv1XOMRPyo+fOAgDIcZ13q7rC6ZjTo053SmSC7cFTjuvGrFCoGTgJ16XXmLZuJUNK1SHjmcAg2hwPuiFjpsdGqwmdglOnBY3rRu2gJJIYjGzNEstp6tnjVuPanrlkU+WVImKcfv8G7H7lKFBT4Ijj38amE1fh84dvxatKYuXwOuy5bwHmDmv87zQBXFk9yeCtt+C4hxn7ByMctXoXtg69F4sbffjjyLE4ZfgqvPHKkYA0OGFwDxILng38lxiMbGoJKij06Lk35fIExjr3nAvdd07y+nBFpu3G9q8P5z14eXCMOsDylhOb8J1st6XoVnXyz4RqQJCBaCmJbIp1hCe3D1R2/OvLH5gRhZpKounmj3WEppY+dVtaJsKEbkC0VASlhU+xivDZO67wd3Znr7gud4P3zfsuzd33tbsJzOZO/nb+1vBj59/kcyddvQmxEYiNQFNHPiVl3ZZkU4Q2wu9WrCMoI7DgX8o3fODx7+Y6HvPk9JQ9/qdbcvlH7l7vnxf9ZjtaKvJJaZsSa+62JBYslbKLzX5MNHZMtULNudO79eYTB4CKa5nWomMR62bwLa0OQlbOWqXRZUt4Y1UTy+ZuRmOUsXcZY/3Ki3Dz8r9gy4752P/QBM5d+h3cv/UHOOOCm4G7qic5dc0mPHXbWqx+33o8942jsW3VPAwNvI4bt56LgYdvxtwtEroPGF4u0F/QI9ms8keOMy8tZa9JpQ4oddnyx3DdmrvTMjA2AsBC4PKnP4cfb70dwPXAXZOE8tsIwDpgGHj2rAVYPOA+LFyaD+WPbV+IS5/4kpu//nNOYjmClQBr8skowpL+XZUdB3r3TmvC5QurP7U8fXAHjBYwWkCryKekrNuiVASlIgjWBFYil/7w2od9w3j3CbmO97y2bFoTXvOf83P54Z3z/POVz14IoylNxiatBYqW3Q1Rys5LA7+8MbXjECMGywKmX8XTnfZHPihMd76gWwbaBucq9JUwVbOEi0uVVRzRFqxCpRujNBKVHtqMm4yRuW1sA0B4rnwHSaqoaGjAchF7UKbXv7LBVMCmiswUAGgHtgWnogG3QZ4OBJR3CdiSQgcJKrdNgZq+8u82sPNu1aZjGKhi2/ZkOCnYUyH1Kj0OFOxMmaz8sKFDoICsb3e+0NkGdkgHKdTkjSadhAplITdvM8ZkYP93wzp0UxZt2ggmlAm5tAZXkIBW3EwWDEQAF85qpF1bJoDY9g+hUAQWHVrVDApp65TVhJzls+LuZuvYNea0HxmADAEmHZDcOA6rnLTnju5LgokUBXCmtFNkB+LE+pK+jLJrVfBVEfjKqNhF8eCQyusxmW4cAEEY+5c4reeoQ6DbBJU6XAoAhIvgJcsBUOaHzMKJHL8kLqQBoawrJa5lIoBlHiAqWFORo3JSZWVdksRgrOX40vRPdtcSjkjKc18MNw6YhF/YAgideU7K3ThMtk+R5OuylKKkblVByFVRi4Dc9Rw7kkXhZpUS0JBvmxmq5MK5OWsESnhCVgXmzPKJyxd5xrsIAUYSTAMwEt7VhAZEDJBOoxgLG7F8tOLAnJgd1pNGKxVWKOcCIrPriUWw5Q0iBmRh69kCIxSsuxHAETuuIhBzzqqy4JeOQpWXPDMnCdVI0hUulPAMAWzC3AHjLMQwuGUXkiycdJ6kPf941DPTFRTI8V0Nn3yKhJBzbpUzb0c8BhCcdw8WKalGMUPE9q/tZ11N9xCMdNblXK2dq2bnr9uzSFuFpCiccwCneGQ/zRSabbjW9hXANADVS+DIgiPHGX1vxmi8NQ5SBiwF4iP7MXFUA63DBEwEQFtwotiCzJHjKvsJCELHCa9HDZK8b0qhC19qJICI7O0pcWodLbbnFpFuLzEgJwx63hgFdr0ObsWgngZ61DyoQw5Ha47wwAvNiFoMMgzdIMdl5Pkp+0pRjGrdloSHhVAMoax1JAe6JC+0fRYx5/9q2PONZpBioNmCGR3H30d/B/POKGi86dqxJ3ChYPvHlqj92I64hUJBB/h23ZZEB38IzBFfhhOEsgCQMkBk3UzEloASIAEAgrCKLgbIfrePlFt0nIDtkrF5+9sLaxvChfxZc85RnnPKbgUAkSNgMtYVkrOJiBlSMIxbPADwnH5E844FlAZkBHNYP0BA1HKLNtbifAQ0nL5yuHyRlOuU9BAYm0LoBCAIcARMDMC4+xjDIAVExthf0bn3rXhuH8ShPQDbeG0aAhwRogkD0bLhHaZwBGhlzwRhqeOMA2QshzSXzVlzIeym7xMUM4jtljPZsK76I/Cc9P0hsZSoadIjAAHsfpdIBVxKUcmBUscZB7DewcJZDlBWMHdCjsjvouUNBpjBgmB6Irt46SIZW3eyJ2RjgSYCSwInb/accSXKWIjXIQWlnptAG5AkaZPXq9SSrDslC2AHDmA5qKXdgOR3XMQGQhkbyUx630HZX7QaeDckMIo/F/ebcRAWO1VJ3SouxMqCn1OgLK10IV9N8nuJ5EWzcKayg7uyRI2aXQqwkRYIgQOEwXC7DHIuJpKXUGPDvEkB4igCpABL4V7O2JJycY5JCLe2E7LzBklNZaNTVjwH2IUBSP8Kt2ABd9FlgFiBlE77SONIKHPbZUx6IebezicDZ9L6GZLEEyS0RvCbFlWKGbbHfp3mAYCjAmkYA4oz4GQtx6TjtwvXgX9F0RWhBBy/475mCkDBRSii1KIAC0Qn4wIp0SeSteI6vhCIDDhotvI1IrBdWRdgTq2ACBQJIIrylmOMdTN20SoBMAtE1pKy5TW5UlaoZY/+kos7XNwuQaXdZbcwIgI0AZJB2S9TMwPaADozVtayghoF6opc2C2JHThQAUJOhCy35OJMhgg4qXGRKgSiL9MZwg5JyGIz3NRN8We/cw5dUz5QBHexrHyJL3zbEG9VsGuwbdVmBcao2NigblPZGCJIMz5eqThNskiP6lQUDCnilOm0bXjcgtX6xh0CGhiTssy4ii7uqFNowiCQVcpVKFhtiRVBosO2HVt4QVfKh432ciDg2eIZcpcZssYpgTOT0jHwwIFbbodW+3/2V4VaxtzB3gAAAABJRU5ErkJggg==" id="image2636f74bf5" transform="scale(1 -1) translate(0 -51.12)" x="241.261714" y="-242.838454" width="51.12" height="51.12"/> - + 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" id="imagef343df5550" transform="scale(1 -1) translate(0 -51.12)" x="302.482286" y="-242.838454" width="51.12" height="51.12"/> - + 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" id="image76dd97cf22" transform="scale(1 -1) translate(0 -51.12)" x="363.702857" y="-242.838454" width="51.12" height="51.12"/> - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/lib/matplotlib/tests/baseline_images/test_image/interp_alpha.png b/lib/matplotlib/tests/baseline_images/test_image/interp_alpha.png index 5679a2f97df8..7129fba6d5b4 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/interp_alpha.png and b/lib/matplotlib/tests/baseline_images/test_image/interp_alpha.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.pdf b/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.pdf index c26419850251..3ff7ac577202 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.pdf and b/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.pdf differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.png b/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.png index 1df80c1b2045..453ea0ab2342 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.png and b/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.png differ diff --git a/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.svg b/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.svg index 259eb2c9c7f3..e9bde5b99554 100644 --- a/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.svg +++ b/lib/matplotlib/tests/baseline_images/test_image/log_scale_image.svg @@ -6,11 +6,11 @@ - 2025-05-14T18:02:41.587512 + 2025-07-10T19:29:53.473547 image/svg+xml - Matplotlib v3.11.0.dev832+gc5ea66e278, https://matplotlib.org/ + Matplotlib v3.11.0.dev1075+g945334b731, https://matplotlib.org/ @@ -39,7 +39,7 @@ z +iVBORw0KGgoAAAANSUhEUgAAAmwAAAHgCAYAAAAYDzEbAAALmElEQVR4nO3dSY5cxwFF0cyf72d1lEhTMkwIAqwFe+BNCrAJkWZbrOy9g5jGG5yzgje8iPjN9o9//+u2AQCg1jJ7AAAAY4INAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgnGADACgn2AAAygk2AIBygg0AoJxgAwAoJ9gAAMoJNgCAcoINAKCcYAMAKCfYAADKCTYAgHKCDQCgXDbb2RMAABjJTbABAFRzJQoAUC6b7W32BgAABjzDBgBQTrABAJQTbAAA5bx0AABQLjcvHQAAVHMlCgBQTrABAJTzDBsAQDnBBgBQzp8OAADKeYYNAKCcYAMAKOdKFACgnBM2AIBygg0AoJwrUQCAcr7DBgBQLltXogAA1VyJAgCU89IBAEC5bJ2wAQBUc8IGAFDOSwcAAOW8dAAAUC4O2AAAunnpAACgnCtRAIByXjoAACjnShQAoJwTNgCAck7YAADKCTYAgHKuRAEAyjlhAwAoJ9gAAMr5NRUAQLnsluvsDQAADLgSBQAol8WdKABANSdsAADlsgg2AIBqTtgAAMo5YQMAKOc7bAAA5RLfYQMAqOYZNgCAcp5hAwAoJ9gAAMpl2Qg2AIBmfv4OAFDOlSgAQDnBBgBQLtleZm8AAGDACRsAQDnBBgBQTrABAJRLtj7rAQDQLItgAwColp0rUQCAaq5EAQDKuRIFACiXVbABAFRzwgYAUM532AAAymX1L1EAgGpO2AAAyjlhAwAol52XDgAAqjlhAwAol2XjGTYAgGZZl/PsDQAADGTnhA0AoJpn2AAAyvk1FQBAOSdsAADlst966QAAoFmWjStRAIBm2bsSBQCo5qUDAIByTtgAAMpl9dIBAEA1fzoAACjnhA0AoJwP5wIAlMt+I9gAAJr5rAcAQLns/ekAAKBaVidsAADVBBsAQLmsvsMGAFAtu+3sCQAAjGSdvQAAgKGsW0dsAADNsm6X2RsAABjIutnN3gAAwEDWrWADAGgm2AAAynmADQCgXE63y+wNAAAMCDYAgHI5bQQbAECznG5+/g4A0Cynm5+/AwA0y2n2AgAAhvJy8y9RAIBmOd18ig0AoJlgAwAol6OfHQAAVMvp5l+iAADNcrpl9gYAAAbycltnbwAAYCBHV6IAANVciQIAlPPSAQBAOc+wAQCUy9GVKABANVeiAADlcri6EgUAaOaEDQCgXF6csAEAVHPCBgBQLoert0QBAJo5YQMAKJejEzYAgGo5XZ2wAQA0y0GwAQBUy1mwAQBUy1GwAQBU89IBAEC5nK/L7A0AAAx4SxQAoFxOF8EGANDMlSgAQDnBBgBQLqeLYAMAaJazZ9gAAKrl4koUAKBaLq5EAQCq5Xrdzt4AAMBArk7YAACqOWEDACiX20WwAQA0y82VKABAtWycsAEAVBNsAADlshVsAADVsrnMngAAwIgTNgCAcrntbrM3AAAwkM1u9gQAAEacsAEAlMtmEWwAAM2yiWADAGiW7e46ewMAAANZnLABAFTLsjhhAwBolsWVKABAtSSCDQCgWXauRAEAqmUff38HAGiWfc6zNwAAMJDVlSgAQLXc7ZywAQA0y50rUQCAatkvgg0AoFnuXYkCAFTLw+40ewMAAAN52B1nbwAAYMAJGwBAuTwuTtgAAJrlcXeYvQEAgAEnbAAA5fK0OGEDAGiWR8EGAFDNCRsAQLk8bT3DBgDQzJUoAEC5PG39SxQAoFl+Wi6zNwAAMJDH7Xb2BgAABvK4XWdvAABgII/LfvYGAAAG8nz1WQ8AgGZ5vp1mbwAAYCBfr7fZGwAAGMjzbTd7AwAAA/l69dIBAECzfLnez94AAMBAnm93szcAADCQLxcnbAAAzfL1+jB7AwAAA/nmhA0AoFq+CjYAgGr5dvHSAQBAs3w/CzYAgGb5fvbhXACAZnkWbAAA1fLjvM7eAADAgGADACiXl3NmbwAAYCCHk2ADAGiWo2ADAKiW82k3ewMAAAO5nJbZGwAAGMhNsAEAVMtGsAEAVMv2tJ29AQCAgWxugg0AoFlu++vsDQAADGSzCjYAgGbZOmEDAKiWrJfZGwAAGBBsAADlcreeZ28AAGAg9/vT7A0AAAzk1f44ewMAAAN5imADAGiWV+th9gYAAAby8/oyewMAAAN5k+fZGwAAGMjr/Ji9AQCAgbzeOWEDAGiWt/k2ewMAAAP5ZSfYAACa5c3iGTYAgGZ5u/hwLgBAs7zd7WZvAABgIK+Xh9kbAAAYyOerZ9gAAJrl4+UyewMAAAP5eN3P3gAAwEA+XJ5mbwAAYCAfL69mbwAAYCAfBBsAQLX8dfpp9gYAAAbyv/Pj7A0AAAzk41GwAQA0y5ejPx0AADTL5+P97A0AAAzk+9GHcwEAmuX5INgAAJrl8LLO3gAAwEDOh93sDQAADGQj2AAAqmV5WWZvAABgINf9dfYGAAAGsrkTbAAAzbK7v8zeAADAQPZ3p9kbAAAYyNP9cfYGAAAG8uruMHsDAAAD+dvd8+wNAAAM5BfBBgBQLX/ff529AQCAgfy6fpu9AQCAgfxj/Tx7AwAAA3mXT7M3AAAwkN92nmEDAGiWd7vZEwAAGMnPy/3sDQAADOT9xXfYAACa5b+XdfYGAAAG8ufl9ewNAAAM5M/T29kbAAAYyPvTz7M3AAAwkP8cXIkCADTL+8Or2RsAABjIh5en2RsAABjIpx8+nAsA0CzfngUbAECznH74cC4AQLPcfvj7OwBAs2yPy+wNAAAM5PZ4mb0BAICB7J5OszcAADCQx8fD7A0AAAzkzcPL7A0AAAzk14dvszcAADCQdw9fZ28AAGAgv919mr0BAICB/L7/OHsDAAAD+WP9a/YGAAAG8s98mb0BAICB/J6H2RsAABjIuvXzdwCAZv78DgBQTrABAJQTbAAA5QQbAEC5/wOssGsMrv9R/AAAAABJRU5ErkJggg==" id="image2e672a6aec" transform="scale(1 -1) translate(0 -345.6)" x="72" y="-43.2" width="446.4" height="345.6"/> - - + + + + + + 2025-10-08T04:52:19.019436 + image/svg+xml + + + Matplotlib v3.11.0.dev1425+gb39ccbe8f, https://matplotlib.org/ + + + + + - + @@ -15,7 +26,7 @@ L 576 432 L 576 0 L 0 0 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> @@ -24,232 +35,252 @@ L 468 388.8 L 468 43.2 L 122.4 43.2 z -" style="fill:#ffffff;"/> +" style="fill: #ffffff"/> - - + + +" style="fill: none; stroke: #000000; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-linejoin: miter; stroke-linecap: square"/> +" style="fill: none; stroke: #000000; stroke-linejoin: miter; stroke-linecap: square"/> - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - +" style="stroke: #000000; stroke-width: 0.5"/> - + - + - +" style="stroke: #000000; stroke-width: 0.5"/> - + - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - + - + - + - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - + - + - + - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - + - + - + - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - + - + - + - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - +" style="stroke: #000000; stroke-width: 0.5"/> - + - + - +" style="stroke: #000000; stroke-width: 0.5"/> - + - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - + - + - + - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - + - + - + - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - + - + - + - + - + - +" clip-path="url(#p31ed4989a5)" style="fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square"/> + + - + - + - + @@ -257,20 +288,21 @@ L 468 388.8 +" style="fill: none; stroke: #ffffff; stroke-width: 5; stroke-linecap: round"/> +" style="fill: none; stroke: #000000; stroke-width: 2; stroke-linecap: round"/> +" style="fill: none; stroke: #ffffff; stroke-width: 5; stroke-linecap: round"/> - - + + + - + - - - - - - + + + + + diff --git a/lib/matplotlib/tests/baseline_images/test_png/pngsuite.png b/lib/matplotlib/tests/baseline_images/test_png/pngsuite.png index e8ba8c51be42..8b567e0a0598 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_png/pngsuite.png and b/lib/matplotlib/tests/baseline_images/test_png/pngsuite.png differ diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py index 88bc9932de07..e55e02d2ee27 100644 --- a/lib/matplotlib/tests/test_axes.py +++ b/lib/matplotlib/tests/test_axes.py @@ -239,8 +239,9 @@ def test_matshow(fig_test, fig_ref): ax_ref.xaxis.set_ticks_position('both') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison([f'formatter_ticker_{i:03d}.png' for i in range(1, 6)], - tol=0 if platform.machine() == 'x86_64' else 0.031) + tol=0.02 if platform.machine() == 'x86_64' else 0.04) def test_formatter_ticker(): import matplotlib.testing.jpl_units as units units.register() @@ -809,7 +810,8 @@ def test_annotate_signature(): assert p1 == p2 -@image_comparison(['fill_units.png'], savefig_kwarg={'dpi': 60}) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['fill_units.png'], savefig_kwarg={'dpi': 60}, tol=0.2) def test_fill_units(): import matplotlib.testing.jpl_units as units units.register() @@ -1516,7 +1518,8 @@ def test_pcolormesh_log_scale(fig_test, fig_ref): ax.set_xscale('log') -@image_comparison(['pcolormesh_datetime_axis.png'], style='mpl20') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['pcolormesh_datetime_axis.png'], style='mpl20', tol=0.3) def test_pcolormesh_datetime_axis(): # Remove this line when this test image is regenerated. plt.rcParams['pcolormesh.snap'] = False @@ -1544,7 +1547,8 @@ def test_pcolormesh_datetime_axis(): label.set_rotation(30) -@image_comparison(['pcolor_datetime_axis.png'], style='mpl20') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['pcolor_datetime_axis.png'], style='mpl20', tol=0.3) def test_pcolor_datetime_axis(): fig = plt.figure() fig.subplots_adjust(hspace=0.4, top=0.98, bottom=.15) @@ -2762,7 +2766,8 @@ def test_stairs_options(): ax.legend(loc=0) -@image_comparison(['test_stairs_datetime.png']) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['test_stairs_datetime.png'], tol=0.2) def test_stairs_datetime(): f, ax = plt.subplots(constrained_layout=True) ax.stairs(np.arange(36), @@ -6501,7 +6506,8 @@ def test_pie_frame_grid(): plt.axis('equal') -@image_comparison(['pie_rotatelabels_true.png'], style='mpl20', tol=0.009) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['pie_rotatelabels_true.png'], style='mpl20', tol=0.1) def test_pie_rotatelabels_true(): # The slices will be ordered and plotted counter-clockwise. labels = 'Hogwarts', 'Frogs', 'Dogs', 'Logs' diff --git a/lib/matplotlib/tests/test_colorbar.py b/lib/matplotlib/tests/test_colorbar.py index 614c7ae5c20c..72e38d32e82f 100644 --- a/lib/matplotlib/tests/test_colorbar.py +++ b/lib/matplotlib/tests/test_colorbar.py @@ -152,6 +152,7 @@ def test_colorbar_extension_inverted_axis(orientation, extend, expected): assert len(cbar._extend_patches) == 1 +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @pytest.mark.parametrize('use_gridspec', [True, False]) @image_comparison(['cbar_with_orientation', 'cbar_locationing', @@ -159,7 +160,7 @@ def test_colorbar_extension_inverted_axis(orientation, extend, expected): 'cbar_sharing', ], extensions=['png'], remove_text=True, - savefig_kwarg={'dpi': 40}) + savefig_kwarg={'dpi': 40}, tol=0.05) def test_colorbar_positioning(use_gridspec): # Remove this line when this test image is regenerated. plt.rcParams['pcolormesh.snap'] = False @@ -731,7 +732,8 @@ def test_colorbar_label(): assert cbar3.ax.get_xlabel() == 'horizontal cbar' -@image_comparison(['colorbar_keeping_xlabel.png'], style='mpl20') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['colorbar_keeping_xlabel.png'], style='mpl20', tol=0.03) def test_keeping_xlabel(): # github issue #23398 - xlabels being ignored in colorbar axis arr = np.arange(25).reshape((5, 5)) diff --git a/lib/matplotlib/tests/test_contour.py b/lib/matplotlib/tests/test_contour.py index 87e2d0ce182e..f397aee2c9c4 100644 --- a/lib/matplotlib/tests/test_contour.py +++ b/lib/matplotlib/tests/test_contour.py @@ -127,8 +127,9 @@ def test_contour_manual_moveto(): assert clabels[0].get_text() == "0" +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(['contour_disconnected_segments'], - remove_text=True, style='mpl20', extensions=['png']) + remove_text=True, style='mpl20', extensions=['png'], tol=0.01) def test_contour_label_with_disconnected_segments(): x, y = np.mgrid[-1:1:21j, -1:1:21j] z = 1 / np.sqrt(0.01 + (x + 0.3) ** 2 + y ** 2) @@ -229,7 +230,8 @@ def test_lognorm_levels(n_levels): assert len(visible_levels) <= n_levels + 1 -@image_comparison(['contour_datetime_axis.png'], style='mpl20') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['contour_datetime_axis.png'], style='mpl20', tol=0.3) def test_contour_datetime_axis(): fig = plt.figure() fig.subplots_adjust(hspace=0.4, top=0.98, bottom=.15) diff --git a/lib/matplotlib/tests/test_dates.py b/lib/matplotlib/tests/test_dates.py index d5b47ac567b4..d3f64d73002e 100644 --- a/lib/matplotlib/tests/test_dates.py +++ b/lib/matplotlib/tests/test_dates.py @@ -152,7 +152,8 @@ def test_date_axhspan(): fig.subplots_adjust(left=0.25) -@image_comparison(['date_axvspan.png']) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['date_axvspan.png'], tol=0.07) def test_date_axvspan(): # test axvspan with date inputs t0 = datetime.datetime(2000, 1, 20) @@ -176,7 +177,8 @@ def test_date_axhline(): fig.subplots_adjust(left=0.25) -@image_comparison(['date_axvline.png']) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['date_axvline.png'], tol=0.09) def test_date_axvline(): # test axvline with date inputs t0 = datetime.datetime(2000, 1, 20) @@ -226,7 +228,8 @@ def wrapper(): return wrapper -@image_comparison(['RRuleLocator_bounds.png']) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['RRuleLocator_bounds.png'], tol=0.07) def test_RRuleLocator(): import matplotlib.testing.jpl_units as units units.register() @@ -270,7 +273,8 @@ def test_RRuleLocator_close_minmax(): assert list(map(str, mdates.num2date(loc.tick_values(d1, d2)))) == expected -@image_comparison(['DateFormatter_fractionalSeconds.png']) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['DateFormatter_fractionalSeconds.png'], tol=0.11) def test_DateFormatter(): import matplotlib.testing.jpl_units as units units.register() diff --git a/lib/matplotlib/tests/test_figure.py b/lib/matplotlib/tests/test_figure.py index e666a3b99f7f..95568d237b91 100644 --- a/lib/matplotlib/tests/test_figure.py +++ b/lib/matplotlib/tests/test_figure.py @@ -25,8 +25,9 @@ import matplotlib.dates as mdates +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(['figure_align_labels'], extensions=['png', 'svg'], - tol=0 if platform.machine() == 'x86_64' else 0.01) + tol=0.1 if platform.machine() == 'x86_64' else 0.1) def test_align_labels(): fig = plt.figure(layout='tight') gs = gridspec.GridSpec(3, 3) @@ -66,9 +67,10 @@ def test_align_labels(): fig.align_labels() +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(['figure_align_titles_tight.png', 'figure_align_titles_constrained.png'], - tol=0 if platform.machine() == 'x86_64' else 0.022, + tol=0.3 if platform.machine() == 'x86_64' else 0.04, style='mpl20') def test_align_titles(): for layout in ['tight', 'constrained']: @@ -320,7 +322,8 @@ def test_add_subplot_invalid(): fig.add_subplot(ax) -@image_comparison(['figure_suptitle.png']) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['figure_suptitle.png'], tol=0.02) def test_suptitle(): fig, _ = plt.subplots() fig.suptitle('hello', color='r') @@ -1396,8 +1399,9 @@ def test_subfigure_ss(): fig.suptitle('Figure suptitle', fontsize='xx-large') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(['test_subfigure_double.png'], style='mpl20', - savefig_kwarg={'facecolor': 'teal'}) + savefig_kwarg={'facecolor': 'teal'}, tol=0.02) def test_subfigure_double(): # test assigning the subfigure via subplotspec np.random.seed(19680801) diff --git a/lib/matplotlib/tests/test_image.py b/lib/matplotlib/tests/test_image.py index 9b598fbf7193..da7a198a2a94 100644 --- a/lib/matplotlib/tests/test_image.py +++ b/lib/matplotlib/tests/test_image.py @@ -1604,8 +1604,8 @@ def test_large_image(fig_test, fig_ref, dim, size, msg, origin): 'accurately displayed.'): fig_test.canvas.draw() - array = np.zeros((1, 2)) - array[:, 1] = 1 + array = np.zeros((1, size // 2 + 1)) + array[:, array.size // 2:] = 1 if dim == 'col': array = array.T im = ax_ref.imshow(array, vmin=0, vmax=1, aspect='auto', @@ -1663,19 +1663,33 @@ def test__resample_valid_output(): [(np.array([[0.1, 0.3, 0.2]]), mimage.NEAREST, np.array([[0.1, 0.1, 0.1, 0.3, 0.3, 0.3, 0.3, 0.2, 0.2, 0.2]])), (np.array([[0.1, 0.3, 0.2]]), mimage.BILINEAR, - np.array([[0.1, 0.1, 0.15078125, 0.21096191, 0.27033691, - 0.28476562, 0.2546875, 0.22460938, 0.20002441, 0.20002441]])), + np.array([[0.1, 0.1, 0.15, 0.21, 0.27, 0.285, 0.255, 0.225, 0.2, 0.2]])), + (np.array([[0.1, 0.9]]), mimage.BILINEAR, + np.array([[0.1, 0.1, 0.1, 0.1, 0.1, 0.14, 0.22, 0.3, 0.38, 0.46, + 0.54, 0.62, 0.7, 0.78, 0.86, 0.9, 0.9, 0.9, 0.9, 0.9]])), + (np.array([[0.1, 0.1]]), mimage.BILINEAR, np.full((1, 10), 0.1)), + # Test at the subpixel level + (np.array([[0.1, 0.9]]), mimage.NEAREST, + np.concatenate([np.full(512, 0.1), np.full(512, 0.9)]).reshape(1, -1)), + (np.array([[0.1, 0.9]]), mimage.BILINEAR, + np.concatenate([np.full(256, 0.1), + np.linspace(0.5, 256, 512).astype(int) / 256 * 0.8 + 0.1, + np.full(256, 0.9)]).reshape(1, -1)), ] ) def test_resample_nonaffine(data, interpolation, expected): - # Test that equivalent affine and nonaffine transforms resample the same + # Test that both affine and nonaffine transforms resample to the correct answer + + # If the array is constant, the tolerance can be tight + # Otherwise, the tolerance is limited by the subpixel approach in the agg backend + atol = 0 if np.all(data == data.ravel()[0]) else 2e-3 # Create a simple affine transform for scaling the input array affine_transform = Affine2D().scale(sx=expected.shape[1] / data.shape[1], sy=1) affine_result = np.empty_like(expected) mimage.resample(data, affine_result, affine_transform, interpolation=interpolation) - assert_allclose(affine_result, expected) + assert_allclose(affine_result, expected, atol=atol) # Create a nonaffine version of the same transform # by compositing with a nonaffine identity transform @@ -1684,13 +1698,13 @@ class NonAffineIdentityTransform(Transform): output_dims = 2 def inverted(self): - return self + return self nonaffine_transform = NonAffineIdentityTransform() + affine_transform nonaffine_result = np.empty_like(expected) mimage.resample(data, nonaffine_result, nonaffine_transform, interpolation=interpolation) - assert_allclose(nonaffine_result, expected, atol=5e-3) + assert_allclose(nonaffine_result, expected, atol=atol) def test_axesimage_get_shape(): diff --git a/lib/matplotlib/tests/test_polar.py b/lib/matplotlib/tests/test_polar.py index 4f9e63380490..4cbb099e3293 100644 --- a/lib/matplotlib/tests/test_polar.py +++ b/lib/matplotlib/tests/test_polar.py @@ -214,7 +214,8 @@ def test_polar_theta_position(): ax.set_theta_direction('clockwise') -@image_comparison(['polar_rlabel_position.png'], style='default') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['polar_rlabel_position.png'], style='default', tol=0.07) def test_polar_rlabel_position(): fig = plt.figure() ax = fig.add_subplot(projection='polar') @@ -229,7 +230,8 @@ def test_polar_title_position(): ax.set_title('foo') -@image_comparison(['polar_theta_wedge.png'], style='default') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['polar_theta_wedge.png'], style='default', tol=0.2) def test_polar_theta_limits(): r = np.arange(0, 3.0, 0.01) theta = 2*np.pi*r diff --git a/lib/matplotlib/tests/test_text.py b/lib/matplotlib/tests/test_text.py index 97b37b91f697..551adbedbc61 100644 --- a/lib/matplotlib/tests/test_text.py +++ b/lib/matplotlib/tests/test_text.py @@ -139,7 +139,8 @@ def test_multiline(): ax.set_yticks([]) -@image_comparison(['multiline2'], style='mpl20') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['multiline2'], style='mpl20', tol=0.05) def test_multiline2(): # Remove this line when this test image is regenerated. plt.rcParams['text.kerning_factor'] = 6 @@ -210,7 +211,8 @@ def test_antialiasing(): mpl.rcParams['text.antialiased'] = False # Should not affect existing text. -@image_comparison(['text_contains.png']) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['text_contains.png'], tol=0.05) def test_contains(): fig = plt.figure() ax = plt.axes() @@ -279,7 +281,8 @@ def test_titles(): ax.set_yticks([]) -@image_comparison(['text_alignment'], style='mpl20') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['text_alignment'], style='mpl20', tol=0.08) def test_alignment(): plt.figure() ax = plt.subplot(1, 1, 1) @@ -1132,8 +1135,9 @@ def test_empty_annotation_get_window_extent(): assert points[0, 1] == 50.0 +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(baseline_images=['basictext_wrap'], - extensions=['png']) + extensions=['png'], tol=0.3) def test_basic_wrap(): fig = plt.figure() plt.axis([0, 10, 0, 10]) @@ -1149,8 +1153,9 @@ def test_basic_wrap(): plt.text(-1, 0, t, ha='left', rotation=-15, wrap=True) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(baseline_images=['fonttext_wrap'], - extensions=['png']) + extensions=['png'], tol=0.3) def test_font_wrap(): fig = plt.figure() plt.axis([0, 10, 0, 10]) @@ -1182,8 +1187,9 @@ def test_va_for_angle(): assert alignment in ['center', 'top', 'baseline'] +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(baseline_images=['xtick_rotation_mode'], - remove_text=False, extensions=['png'], style='mpl20') + remove_text=False, extensions=['png'], style='mpl20', tol=0.3) def test_xtick_rotation_mode(): fig, ax = plt.subplots(figsize=(12, 1)) ax.set_yticks([]) @@ -1202,8 +1208,9 @@ def test_xtick_rotation_mode(): plt.subplots_adjust(left=0.01, right=0.99, top=.6, bottom=.4) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(baseline_images=['ytick_rotation_mode'], - remove_text=False, extensions=['png'], style='mpl20') + remove_text=False, extensions=['png'], style='mpl20', tol=0.3) def test_ytick_rotation_mode(): fig, ax = plt.subplots(figsize=(1, 12)) ax.set_xticks([]) diff --git a/lib/matplotlib/tests/test_units.py b/lib/matplotlib/tests/test_units.py index d2350667e94f..c13c54a101fc 100644 --- a/lib/matplotlib/tests/test_units.py +++ b/lib/matplotlib/tests/test_units.py @@ -80,8 +80,9 @@ def default_units(value, axis): # Tests that the conversion machinery works properly for classes that # work as a facade over numpy arrays (like pint) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(['plot_pint.png'], style='mpl20', - tol=0 if platform.machine() == 'x86_64' else 0.03) + tol=0.03 if platform.machine() == 'x86_64' else 0.04) def test_numpy_facade(quantity_converter): # use former defaults to match existing baseline image plt.rcParams['axes.formatter.limits'] = -7, 7 @@ -142,8 +143,9 @@ def test_jpl_bar_units(): ax.set_ylim([b - 1 * day, b + w[-1] + (1.001) * day]) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(['jpl_barh_units.png'], - savefig_kwarg={'dpi': 120}, style='mpl20') + savefig_kwarg={'dpi': 120}, style='mpl20', tol=0.02) def test_jpl_barh_units(): import matplotlib.testing.jpl_units as units units.register() diff --git a/lib/matplotlib/tests/test_usetex.py b/lib/matplotlib/tests/test_usetex.py index cd9f2597361b..78d9fd6cc948 100644 --- a/lib/matplotlib/tests/test_usetex.py +++ b/lib/matplotlib/tests/test_usetex.py @@ -226,8 +226,9 @@ def test_pdf_type1_font_subsetting(): _old_gs_version = True +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @image_comparison(baseline_images=['rotation'], extensions=['eps', 'pdf', 'png', 'svg'], - style='mpl20', tol=3.91 if _old_gs_version else 0) + style='mpl20', tol=3.91 if _old_gs_version else 0.2) def test_rotation(): mpl.rcParams['text.usetex'] = True diff --git a/lib/mpl_toolkits/axes_grid1/tests/baseline_images/test_axes_grid1/inset_locator.png b/lib/mpl_toolkits/axes_grid1/tests/baseline_images/test_axes_grid1/inset_locator.png index c7ad1e64b84d..17a1460f6be4 100644 Binary files a/lib/mpl_toolkits/axes_grid1/tests/baseline_images/test_axes_grid1/inset_locator.png and b/lib/mpl_toolkits/axes_grid1/tests/baseline_images/test_axes_grid1/inset_locator.png differ diff --git a/lib/mpl_toolkits/axisartist/tests/test_axis_artist.py b/lib/mpl_toolkits/axisartist/tests/test_axis_artist.py index d44a61b6dd4a..96d8a2cde0f3 100644 --- a/lib/mpl_toolkits/axisartist/tests/test_axis_artist.py +++ b/lib/mpl_toolkits/axisartist/tests/test_axis_artist.py @@ -24,7 +24,8 @@ def test_ticks(): ax.add_artist(ticks_out) -@image_comparison(['axis_artist_labelbase.png'], style='default') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['axis_artist_labelbase.png'], style='default', tol=0.02) def test_labelbase(): # Remove this line when this test image is regenerated. plt.rcParams['text.kerning_factor'] = 6 @@ -41,7 +42,8 @@ def test_labelbase(): ax.add_artist(label) -@image_comparison(['axis_artist_ticklabels.png'], style='default') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['axis_artist_ticklabels.png'], style='default', tol=0.03) def test_ticklabels(): # Remove this line when this test image is regenerated. plt.rcParams['text.kerning_factor'] = 6 @@ -76,7 +78,8 @@ def test_ticklabels(): ax.set_ylim(0, 1) -@image_comparison(['axis_artist.png'], style='default') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['axis_artist.png'], style='default', tol=0.03) def test_axis_artist(): # Remove this line when this test image is regenerated. plt.rcParams['text.kerning_factor'] = 6 diff --git a/lib/mpl_toolkits/axisartist/tests/test_axislines.py b/lib/mpl_toolkits/axisartist/tests/test_axislines.py index a1485d4f436b..a47ab2ea8a31 100644 --- a/lib/mpl_toolkits/axisartist/tests/test_axislines.py +++ b/lib/mpl_toolkits/axisartist/tests/test_axislines.py @@ -7,7 +7,8 @@ from mpl_toolkits.axisartist import Axes, SubplotHost -@image_comparison(['SubplotZero.png'], style='default') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['SubplotZero.png'], style='default', tol=0.02) def test_SubplotZero(): # Remove this line when this test image is regenerated. plt.rcParams['text.kerning_factor'] = 6 @@ -28,7 +29,8 @@ def test_SubplotZero(): ax.set_ylabel("Test") -@image_comparison(['Subplot.png'], style='default') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['Subplot.png'], style='default', tol=0.02) def test_Subplot(): # Remove this line when this test image is regenerated. plt.rcParams['text.kerning_factor'] = 6 @@ -130,7 +132,8 @@ def test_axisline_style_tight(): ax.axis[direction].set_visible(False) -@image_comparison(['subplotzero_ylabel.png'], style='mpl20') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['subplotzero_ylabel.png'], style='mpl20', tol=0.02) def test_subplotzero_ylabel(): fig = plt.figure() ax = fig.add_subplot(111, axes_class=SubplotZero) diff --git a/lib/mpl_toolkits/axisartist/tests/test_grid_helper_curvelinear.py b/lib/mpl_toolkits/axisartist/tests/test_grid_helper_curvelinear.py index 7d6554782fe6..ac31b8b30c97 100644 --- a/lib/mpl_toolkits/axisartist/tests/test_grid_helper_curvelinear.py +++ b/lib/mpl_toolkits/axisartist/tests/test_grid_helper_curvelinear.py @@ -76,7 +76,8 @@ def inverted(self): ax1.grid(True) -@image_comparison(['polar_box.png'], style='default', tol=0.04) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['polar_box.png'], style='default', tol=0.09) def test_polar_box(): fig = plt.figure(figsize=(5, 5)) @@ -136,7 +137,7 @@ def test_polar_box(): # Remove tol & kerning_factor when this test image is regenerated. -@image_comparison(['axis_direction.png'], style='default', tol=0.13) +@image_comparison(['axis_direction.png'], style='default', tol=0.15) def test_axis_direction(): plt.rcParams['text.kerning_factor'] = 6 diff --git a/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py b/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py index 546659d05177..387a2e6763ce 100644 --- a/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py +++ b/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py @@ -645,7 +645,8 @@ def test_surface3d(): fig.colorbar(surf, shrink=0.5, aspect=5) -@image_comparison(['surface3d_label_offset_tick_position.png'], style='mpl20') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@image_comparison(['surface3d_label_offset_tick_position.png'], style='mpl20', tol=0.07) def test_surface3d_label_offset_tick_position(): plt.rcParams['axes3d.automargin'] = True # Remove when image is regenerated ax = plt.figure().add_subplot(projection="3d") @@ -741,7 +742,8 @@ def test_surface3d_masked_strides(): ax.view_init(60, -45, 0) -@mpl3d_image_comparison(['text3d.png'], remove_text=False, style='mpl20') +# TODO: tighten tolerance after baseline image is regenerated for text overhaul +@mpl3d_image_comparison(['text3d.png'], remove_text=False, style='mpl20', tol=0.1) def test_text3d(): fig = plt.figure() ax = fig.add_subplot(projection='3d') @@ -1120,8 +1122,9 @@ def test_poly3dCollection_autoscaling(): assert np.allclose(ax.get_zlim3d(), (-0.0833333333333333, 4.083333333333333)) +# TODO: tighten tolerance after baseline image is regenerated for text overhaul @mpl3d_image_comparison(['axes3d_labelpad.png'], - remove_text=False, style='mpl20') + remove_text=False, style='mpl20', tol=0.06) def test_axes3d_labelpad(): fig = plt.figure() ax = fig.add_axes(Axes3D(fig)) diff --git a/meson.build b/meson.build index 54249473fe8e..47244656705f 100644 --- a/meson.build +++ b/meson.build @@ -31,6 +31,10 @@ project( ], ) +# Enable bug fixes in Agg +add_project_arguments('-DMPL_FIX_AGG_IMAGE_FILTER_LUT_BUGS', language : 'cpp') +add_project_arguments('-DMPL_FIX_AGG_INTERPOLATION_ENDPOINT_BUG', language : 'cpp') + cc = meson.get_compiler('c') cpp = meson.get_compiler('cpp') diff --git a/src/_image_resample.h b/src/_image_resample.h index 6b325c8aa14b..1b7af133de31 100644 --- a/src/_image_resample.h +++ b/src/_image_resample.h @@ -569,23 +569,28 @@ class lookup_distortion { public: lookup_distortion(const double *mesh, int in_width, int in_height, - int out_width, int out_height) : + int out_width, int out_height, bool edge_aligned_subpixels) : m_mesh(mesh), m_in_width(in_width), m_in_height(in_height), m_out_width(out_width), - m_out_height(out_height) + m_out_height(out_height), + m_edge_aligned_subpixels(edge_aligned_subpixels) {} void calculate(int* x, int* y) { if (m_mesh) { + // Nearest-neighbor interpolation needs edge-aligned subpixels + // All other interpolation approaches need center-aligned subpixels + double offset = m_edge_aligned_subpixels ? 0 : 0.5; + double dx = double(*x) / agg::image_subpixel_scale; double dy = double(*y) / agg::image_subpixel_scale; if (dx >= 0 && dx < m_out_width && dy >= 0 && dy < m_out_height) { const double *coord = m_mesh + (int(dy) * m_out_width + int(dx)) * 2; - *x = int(coord[0] * agg::image_subpixel_scale); - *y = int(coord[1] * agg::image_subpixel_scale); + *x = int(coord[0] * agg::image_subpixel_scale + offset); + *y = int(coord[1] * agg::image_subpixel_scale + offset); } } } @@ -596,6 +601,7 @@ class lookup_distortion int m_in_height; int m_out_width; int m_out_height; + bool m_edge_aligned_subpixels; }; @@ -781,7 +787,7 @@ void resample( using span_conv_t = agg::span_converter; using nn_renderer_t = agg::renderer_scanline_aa; lookup_distortion dist( - params.transform_mesh, in_width, in_height, out_width, out_height); + params.transform_mesh, in_width, in_height, out_width, out_height, true); arbitrary_interpolator_t interpolator(inverted, dist); span_gen_t span_gen(input_accessor, interpolator); span_conv_t span_conv(span_gen, conv_alpha); @@ -806,7 +812,7 @@ void resample( using span_conv_t = agg::span_converter; using int_renderer_t = agg::renderer_scanline_aa; lookup_distortion dist( - params.transform_mesh, in_width, in_height, out_width, out_height); + params.transform_mesh, in_width, in_height, out_width, out_height, false); arbitrary_interpolator_t interpolator(inverted, dist); span_gen_t span_gen(input_accessor, interpolator, filter); span_conv_t span_conv(span_gen, conv_alpha); diff --git a/src/_image_wrapper.cpp b/src/_image_wrapper.cpp index 6528c4a9270c..c062ef14a8f1 100644 --- a/src/_image_wrapper.cpp +++ b/src/_image_wrapper.cpp @@ -167,12 +167,17 @@ image_resample(py::array input_array, if (is_affine) { convert_trans_affine(transform, params.affine); - params.is_affine = true; - } else { + // If affine parameters will make subpixels visible, treat as nonaffine instead + if (params.affine.sx >= agg::image_subpixel_scale / 2 || params.affine.sy >= agg::image_subpixel_scale / 2) { + is_affine = false; + params.affine = agg::trans_affine(); // reset to identity affine parameters + } + } + if (!is_affine) { transform_mesh = _get_transform_mesh(transform, output_array.shape()); params.transform_mesh = transform_mesh.data(); - params.is_affine = false; } + params.is_affine = is_affine; } if (auto resampler =