@reekon-tools/react-native-pdf-canvas 0.2.1 → 0.3.0

package/native/tests/test_document.cpp

@@ -329,6 +329,184 @@ TEST(openBytesMatchesOpenFile) {
   CHECK_EQ(px::compare(a, b).differing, 0);
 }
 
+/* ------------------------------------------------------------------ *
+ * Host rotation — on top of the document's /Rotate
+ * ------------------------------------------------------------------ */
+
+namespace {
+
+RasterRequest turned(RasterRequest request, int rotation) {
+  request.rotation = rotation;
+  return request;
+}
+
+/// `upright` turned `rotation` degrees clockwise, pixel for pixel — the
+/// reference a rotated render is held to. Per case rather than
+/// transpose-plus-flip, so the DIRECTION is stated and not derived: a core
+/// turning pages anticlockwise would still be "a rotation".
+RasterPixels turnClockwise(const RasterPixels& upright, int rotation) {
+  const bool swap = rotation != 180;
+  RasterPixels out;
+  out.width = swap ? upright.height : upright.width;
+  out.height = swap ? upright.width : upright.height;
+  out.rowBytes = out.width * 4;
+  out.bytes.assign(static_cast<size_t>(out.rowBytes) * static_cast<size_t>(out.height), 0);
+  for (int y = 0; y < out.height; y++) {
+    for (int x = 0; x < out.width; x++) {
+      int sx = 0;
+      int sy = 0;
+      if (rotation == 90) {
+        sx = y;
+        sy = upright.height - 1 - x;
+      } else if (rotation == 180) {
+        sx = upright.width - 1 - x;
+        sy = upright.height - 1 - y;
+      } else {
+        sx = upright.width - 1 - y;
+        sy = x;
+      }
+      const uint8_t* from = upright.bytes.data() + static_cast<size_t>(sy) * upright.rowBytes +
+                            static_cast<size_t>(sx) * 4;
+      uint8_t* to = out.bytes.data() + static_cast<size_t>(y) * out.rowBytes + static_cast<size_t>(x) * 4;
+      std::copy(from, from + 4, to);
+    }
+  }
+  return out;
+}
+
+/// The registration page's pattern: bars 2.5pt wide on 13.3 / 11.1pt
+/// intervals, so every edge sits on a fraction of a device pixel at every
+/// scale and no rect can align with it by accident. Axis-aligned throughout.
+std::string fractionalBars() {
+  std::string content = "1 0 0 rg 0 0 100 50 re f\n0 0 1 rg 100 50 100 50 re f\n0.2 0.2 0.25 rg\n";
+  for (double x = 3.7; x < 200; x += 13.3) content += std::to_string(x) + " 0 2.5 100 re f\n";
+  for (double y = 2.9; y < 100; y += 11.1) content += "0 " + std::to_string(y) + " 200 2.5 re f\n";
+  return content;
+}
+
+}  // namespace
+
+/// CATCHES: the rotate argument ignored, applied anticlockwise, or applied
+/// without swapping the page box PDFium is handed — which squashes the turned
+/// page into the upright box. Quadrants, so every corner is a channel-order
+/// test too. Doc (y-down): TL blue, TR black, BL red, BR green.
+TEST(aHostRotationTurnsThePageClockwise) {
+  auto document = openFixture(fixtures::quadrants(200, 100), "host-rotate.pdf");
+
+  // The whole page, in the TURNED page's doc space: 100x200 at 90 and 270.
+  auto r90 = document->render(turned(px::request(0, 0, 0, 100, 200, 2), 90), nullptr, nullptr);
+  CHECK_EQ(r90.width, 200);
+  CHECK_EQ(r90.height, 400);
+  CHECK_PIXEL(r90, 20, 20, kRed);      // BL -> TL
+  CHECK_PIXEL(r90, 180, 20, kBlue);    // TL -> TR
+  CHECK_PIXEL(r90, 180, 380, kBlack);  // TR -> BR
+  CHECK_PIXEL(r90, 20, 380, kGreen);   // BR -> BL
+
+  auto r180 = document->render(turned(px::request(0, 0, 0, 200, 100, 2), 180), nullptr, nullptr);
+  CHECK_EQ(r180.width, 400);
+  CHECK_EQ(r180.height, 200);
+  CHECK_PIXEL(r180, 20, 20, kGreen);   // BR -> TL
+  CHECK_PIXEL(r180, 380, 20, kRed);    // BL -> TR
+  CHECK_PIXEL(r180, 380, 180, kBlue);  // TL -> BR
+  CHECK_PIXEL(r180, 20, 180, kBlack);  // TR -> BL
+
+  auto r270 = document->render(turned(px::request(0, 0, 0, 100, 200, 2), 270), nullptr, nullptr);
+  CHECK_EQ(r270.width, 200);
+  CHECK_EQ(r270.height, 400);
+  CHECK_PIXEL(r270, 20, 20, kBlack);   // TR -> TL
+  CHECK_PIXEL(r270, 180, 20, kGreen);  // BR -> TR
+  CHECK_PIXEL(r270, 180, 380, kRed);   // BL -> BR
+  CHECK_PIXEL(r270, 20, 380, kBlue);   // TL -> BL
+}
+
+/// Pixel for pixel, not just the corners, on fractionally placed axis-aligned
+/// ink: a quarter turn keeps every edge axis-aligned at a mirrored fractional
+/// offset, whose coverage the rasterizer accumulates to the identical value —
+/// so the turned render must EQUAL the upright one turned, with no tolerance.
+/// (The web backend measures the same against the same PDFium build.)
+TEST(aRotatedRasterIsTheUprightRasterTurned) {
+  auto document = openFixture(fixtures::page({0, 0, 200, 100}, nullptr, 0, fractionalBars()), "host-rotate-exact.pdf");
+  auto upright = px::renderWhole(*document, 0, 2);
+  for (int rotation : {90, 180, 270}) {
+    const bool swap = rotation != 180;
+    auto rotated = document->render(
+        turned(px::request(0, 0, 0, swap ? 100 : 200, swap ? 200 : 100, 2), rotation), nullptr, nullptr);
+    auto expected = turnClockwise(upright, rotation);
+    CHECK_EQ(rotated.width, expected.width);
+    CHECK_EQ(rotated.height, expected.height);
+    const auto diff = px::compare(rotated, expected);
+    CHECK_MSG(diff.differing == 0, std::to_string(rotation) + ": " + std::to_string(diff.differing) + "/" +
+                                       std::to_string(diff.total) + " pixels differ, maxDelta " +
+                                       std::to_string(diff.maxDelta));
+  }
+}
+
+/// The registration property survives the turn: a tile of a rotated page is
+/// that region of the rotated whole page. The detail layer only ever draws
+/// tiles, so a rotation that held for whole-page renders alone would ship
+/// soft, misregistered detail. Same `maxDelta <= 1` allowance as the upright
+/// property, for the same diagonal-edge reason.
+TEST(aRotatedTileRegistersAgainstTheRotatedPage) {
+  auto document = openFixture(fixtures::grid(200, 100), "host-rotate-tile.pdf");
+  const double scale = 4.0;
+  auto whole = document->render(turned(px::request(0, 0, 0, 100, 200, scale), 90), nullptr, nullptr);
+  auto tile = document->render(turned(px::request(0, 37, 23, 41, 64, scale), 90), nullptr, nullptr);
+  CHECK_EQ(tile.width, 164);
+  CHECK_EQ(tile.height, 256);
+  const auto diff = px::compare(tile, whole, static_cast<int>(37 * scale), static_cast<int>(23 * scale));
+  const std::string summary = std::to_string(diff.differing) + "/" + std::to_string(diff.total) +
+                              " pixels differ, maxDelta " + std::to_string(diff.maxDelta);
+  CHECK_MSG(diff.maxDelta <= 1, summary);
+  CHECK_MSG(diff.differing * 100 < diff.total * 2, summary);
+}
+
+/// The host's rotation STACKS on the document's own /Rotate rather than
+/// replacing it: a page saved with /Rotate 90 and shown turned another 270 is
+/// upright, and draws exactly as the same content saved unrotated.
+TEST(hostRotationStacksOnTheDocumentsRotate) {
+  auto saved = openFixture(fixtures::rotated(90), "host-stack-saved.pdf");  // PDFium reports 792x612
+  auto plain = openFixture(fixtures::rotated(0), "host-stack-plain.pdf");   // 612x792
+  CHECK_NEAR(saved->geometry(0).width, 792, 0.01);
+  // Turned 270 by the host, the saved page is 612x792 in doc space again.
+  auto unwound = saved->render(turned(px::request(0, 0, 0, 612, 792, 0.5), 270), nullptr, nullptr);
+  auto upright = px::renderWhole(*plain, 0, 0.5);
+  CHECK_EQ(unwound.width, 306);
+  CHECK_EQ(unwound.height, 396);
+  CHECK_EQ(px::compare(unwound, upright).differing, 0);
+  // And the markers sit where the unrotated fixture puts them.
+  CHECK_PIXEL(unwound, 20, 20, kRed);
+  CHECK_PIXEL(unwound, 20, 380, kBlue);
+}
+
+/// Form fields turn with the page: `FPDF_FFLDraw` takes the same rotate
+/// argument and the same swapped box as the content pass, so a widget lands
+/// where the turned content says and not where the upright page had it.
+TEST(formFieldsTurnWithThePage) {
+  auto document = openFixture(fixtures::formFieldPage(), "host-rotate-form.pdf");
+  auto with = document->render(turned(px::request(0, 0, 0, 200, 200, 1, true), 90), nullptr, nullptr);
+  // The widget's centre, doc (100,125), turned a quarter clockwise on a
+  // 200x200 page: (200 - 125, 100) = (75, 100).
+  const px::Pixel inside = px::at(with, 75, 100);
+  CHECK_MSG(!inside.near(kWhite), "the turned widget must paint at (75,100); got " + inside.str() + "\n" + px::map(with));
+  // (150,100) came from upright (100,50), above the widget: plain page.
+  CHECK_PIXEL(with, 150, 100, kWhite);
+  // The content's red marker, upright at doc (10..40, 160..190), turns to
+  // (10..40, 10..40).
+  CHECK_PIXEL(with, 25, 25, kRed);
+}
+
+/// Refused, not folded: `45 / 90` is 0 in integer arithmetic, and a request
+/// that asked for a turn must not quietly come back upright.
+TEST(aRotationThatIsNotAQuarterTurnIsRefused) {
+  auto document = openFixture(fixtures::quadrants(40, 40), "host-rotate-bad.pdf");
+  for (int bad : {45, -90, 360, 1}) {
+    EXPECT_ERROR(document->render(turned(px::request(0, 0, 0, 40, 40, 1), bad), nullptr, nullptr),
+                 ErrorCode::BackendFailure);
+  }
+  // And the page is still usable afterwards.
+  CHECK_EQ(px::renderWhole(*document, 0).width, 40);
+}
+
 /* ------------------------------------------------------------------ *
  * Failures
  * ------------------------------------------------------------------ */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/react-native-pdf-canvas",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "PDF pages as Skia images, drawn at exact doc-space rects inside somebody else's transform. One PDFium engine on iOS, Android and web. Owns no canvas, no gestures, no viewport state.",
   "author": "REEKON Tools",
   "license": "Apache-2.0",