penpot/common/test/common_tests/geom_shapes_test.cljc
alonso.torres 81fc3008b3 🐛 Flip one axis when a reflection turns both edges a right angle
A transform finds a reflection by comparing each edge with its image: a
reversed edge toggles that axis's flip and negates the rotation. A mirror
at 45 degrees to the edges turns both edges by a right angle, so neither
reverses. Flipping a shape rotated by an odd multiple of 45 degrees left
its flags and rotation unflipped while its transform was mirrored, or set
both flags, which describe a turn.

Tell a reflection by the reversed orientation of the edges. A reflection
flips exactly one axis; when neither edge reverses, flip the one that keeps
the final rotation along the new x edge. Without area, keep comparing
edges alone.

A fresh JVM swap run (seed 20261101) found this: a rotated, switched board
was flipped, and its copies later failed I4 on rotation. The regression
fails at 45, 135, 225 and 315 degrees on both axes before the fix and
passes after it. The full common JVM suite passes at seed 712: 2067 tests /
33827 assertions.

Compare lower-quantile milliseconds with the saved baseline; keep that
baseline unchanged. The machine/JVM warning makes ratios rough. No world
is flagged.

World                      Baseline       Now    Ratio
Main into 10 copies           1.790     0.910     0.51
Main into 100 copies         15.415     9.264     0.60
Main into 1000 copies       153.086    91.084     0.59
Three nesting levels         35.215    18.132     0.51
Dependency chain             68.931    35.513     0.52
Library update               83.083    43.320     0.52
Many plain shapes             4.837     2.291     0.47
Variant switch               32.052    20.011     0.62

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:42 +01:00

318 lines
14 KiB
Clojure

;; This Source Code Form is subject to the terms of the Mozilla Public
;; License, v. 2.0. If a copy of the MPL was not distributed with this
;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
;;
;; Copyright (c) KALEIDOS SUBSIDIARY SL
(ns common-tests.geom-shapes-test
(:require
[app.common.geom.matrix :as gmt]
[app.common.geom.point :as gpt]
[app.common.geom.rect :as grc]
[app.common.geom.shapes :as gsh]
[app.common.geom.shapes.intersect :as gsin]
[app.common.geom.shapes.transforms :as gsht]
[app.common.math :as mth :refer [close?]]
[app.common.types.modifiers :as ctm]
[app.common.types.path :as path]
[app.common.types.shape :as cts]
[clojure.test :as t]))
(def default-path
[{:command :move-to :params {:x 0 :y 0}}
{:command :line-to :params {:x 20 :y 20}}
{:command :line-to :params {:x 30 :y 30}}
{:command :curve-to :params {:x 40 :y 40 :c1x 35 :c1y 35 :c2x 45 :c2y 45}}
{:command :close-path}])
(defn create-test-shape
([type] (create-test-shape type {}))
([type params]
(if (= type :path)
(cts/setup-shape
(into {:type :path
:content (path/content (:content params default-path))}
params))
(cts/setup-shape
(into {:type type
:width 20
:height 20}
params)))))
(t/deftest regrouping-preserves-the-representation-of-unflipped-axes
(doseq [horizontal [{} {:flip-x nil} {:flip-x false}]
vertical [{} {:flip-y nil} {:flip-y false}]]
(let [group (merge (dissoc (create-test-shape :group) :flip-x :flip-y) horizontal vertical)
child (create-test-shape :rect)
after (gsh/update-group-selrect group [child])]
(t/is (= (select-keys group [:flip-x :flip-y]) (select-keys after [:flip-x :flip-y])))
(t/is (gsh/close-attrs? :points (:points child) (:points after) 1e-10))
(t/is (= (select-keys after [:flip-x :flip-y])
(select-keys (gsh/update-group-selrect after [child]) [:flip-x :flip-y]))))))
(t/deftest regrouping-still-recalculates-stale-flip-flags
(let [group (create-test-shape :group {:flip-x true :flip-y true})
child (create-test-shape :rect)
after (gsh/update-group-selrect group [child])]
(t/is (false? (:flip-x after)))
(t/is (false? (:flip-y after)))
(t/is (gsh/close-attrs? :points (:points child) (:points after) 1e-10))))
(t/deftest transform-shapes
(t/testing "Shape without modifiers should stay the same"
(t/are [type]
(let [shape-before (create-test-shape type)
shape-after (gsh/transform-shape shape-before)]
(= shape-before shape-after))
:rect :path))
(t/testing "Transform shape with translation modifiers"
(doseq [type [:rect :path]]
(let [modifiers (ctm/move-modifiers (gpt/point 10 -10))
shape-before (create-test-shape type {:modifiers modifiers})
shape-after (gsh/transform-shape shape-before)]
(t/is (not= shape-before shape-after))
(t/is (close? (get-in shape-before [:selrect :x])
(- 10 (get-in shape-after [:selrect :x]))))
(t/is (close? (get-in shape-before [:selrect :y])
(+ 10 (get-in shape-after [:selrect :y]))))
(t/is (close? (get-in shape-before [:selrect :width])
(get-in shape-after [:selrect :width])))
(t/is (close? (get-in shape-before [:selrect :height])
(get-in shape-after [:selrect :height]))))))
(t/testing "Transform with empty translation"
(t/are [type]
(let [modifiers {:displacement (gmt/matrix)}
shape-before (create-test-shape type {:modifiers modifiers})
shape-after (gsh/transform-shape shape-before)]
(t/are [prop]
(t/is (close? (get-in shape-before [:selrect prop])
(get-in shape-after [:selrect prop])))
:x :y :width :height :x1 :y1 :x2 :y2))
:rect :path))
(t/testing "Transform shape with resize modifiers"
(t/are [type]
(let [modifiers (ctm/resize-modifiers (gpt/point 2 2) (gpt/point 0 0))
shape-before (create-test-shape type {:modifiers modifiers})
shape-after (gsh/transform-shape shape-before)]
(t/is (not= shape-before shape-after))
(t/is (close? (get-in shape-before [:selrect :x])
(get-in shape-after [:selrect :x])))
(t/is (close? (get-in shape-before [:selrect :y])
(get-in shape-after [:selrect :y])))
(t/is (close? (* 2 (get-in shape-before [:selrect :width]))
(get-in shape-after [:selrect :width])))
(t/is (close? (* 2 (get-in shape-before [:selrect :height]))
(get-in shape-after [:selrect :height]))))
:rect :path))
(t/testing "Transform with empty resize"
(t/are [type]
(let [modifiers (ctm/resize-modifiers (gpt/point 1 1) (gpt/point 0 0))
shape-before (create-test-shape type {:modifiers modifiers})
shape-after (gsh/transform-shape shape-before)]
(t/are [prop]
(t/is (close? (get-in shape-before [:selrect prop])
(get-in shape-after [:selrect prop])))
:x :y :width :height :x1 :y1 :x2 :y2))
:rect :path))
(t/testing "Transform with resize=0"
(let [modifiers (ctm/resize-modifiers (gpt/point 0 0) (gpt/point 0 0))
shape-before (create-test-shape :rect {:modifiers modifiers})
shape-after (gsh/transform-shape shape-before)]
(t/is (close? 0.01 (get-in shape-after [:selrect :width])))
(t/is (close? 0.01 (get-in shape-after [:selrect :height])))))
(t/testing "Transform shape with rotation modifiers"
(t/are [type]
(let [shape-before (create-test-shape type)
modifiers (ctm/rotation-modifiers shape-before (gsh/shape->center shape-before) 30)
shape-before (assoc shape-before :modifiers modifiers)
shape-after (gsh/transform-shape shape-before)]
(t/is (close? (get-in shape-before [:selrect :x])
(get-in shape-after [:selrect :x])))
(t/is (close? (get-in shape-before [:selrect :y])
(get-in shape-after [:selrect :y])))
(t/is (= (count (:points shape-before)) (count (:points shape-after))))
(for [idx (range 0 (count (:point shape-before)))]
(do (t/is (not (close? (get-in shape-before [:points idx :x])
(get-in shape-after [:points idx :x]))))
(t/is (not (close? (get-in shape-before [:points idx :y])
(get-in shape-after [:points idx :y])))))))
:rect :path))
(t/testing "Transform shape with rotation = 0 should leave equal selrect"
(t/are [type]
(let [shape-before (create-test-shape type)
modifiers (ctm/rotation-modifiers shape-before (gsh/shape->center shape-before) 0)
shape-after (gsh/transform-shape (assoc shape-before :modifiers modifiers))]
(t/are [prop]
(t/is (close? (get-in shape-before [:selrect prop])
(get-in shape-after [:selrect prop])))
:x :y :width :height :x1 :y1 :x2 :y2))
:rect :path))
(t/testing "Transform shape with invalid selrect fails gracefully"
(t/are [type selrect]
(let [modifiers (ctm/move-modifiers 0 0)
shape-before (create-test-shape type {:selrect selrect})
shape-after (gsh/transform-shape shape-before modifiers)]
(t/is (grc/close-rect? (:selrect shape-before)
(:selrect shape-after))))
:rect (grc/make-rect 0 0 ##Inf ##Inf)
:path (grc/make-rect 0 0 ##Inf ##Inf))))
(t/deftest points-to-selrect
(let [points [(gpt/point 0.5 0.5)
(gpt/point -1 -2)
(gpt/point 20 65.2)
(gpt/point 12 -10)]
result (grc/points->rect points)
expect {:x -1.0, :y -10.0, :width 21.0, :height 75.2}]
(t/is (= (:x expect) (:x result)))
(t/is (= (:y expect) (:y result)))
(t/is (= (:width expect) (:width result)))
(t/is (= (:height expect) (:height result)))))
(def g45 (mth/radians 45))
(t/deftest points-transform-matrix
(t/testing "Transform matrix"
(t/are [selrect points expected]
(let [result (gsht/transform-points-matrix selrect points)]
(t/is (gmt/close? expected result)))
;; No transformation
(grc/make-rect 0 0 10 10)
(-> (grc/make-rect 0 0 10 10)
(grc/rect->points))
(gmt/matrix)
;; Displacement
(grc/make-rect 0 0 10 10)
(-> (grc/make-rect 20 20 10 10)
(grc/rect->points))
(gmt/matrix 1 0 0 1 20 20)
;; Resize
(grc/make-rect 0 0 10 10)
(-> (grc/make-rect 0 0 20 40)
(grc/rect->points))
(gmt/matrix 2 0 0 4 0 0)
;; Displacement+Resize
(grc/make-rect 0 0 10 10)
(-> (grc/make-rect 10 10 20 40)
(grc/rect->points))
(gmt/matrix 2 0 0 4 10 10)
;; Rotation
(grc/make-rect 0 0 10 10)
(-> (grc/make-rect 0 0 10 10)
(grc/rect->points)
(gsh/transform-points (gmt/rotate-matrix 45)))
(gmt/matrix (mth/cos g45) (mth/sin g45) (- (mth/sin g45)) (mth/cos g45) 0 0)
;; Rotation + Resize
(grc/make-rect 0 0 10 10)
(-> (grc/make-rect 0 0 20 40)
(grc/rect->points)
(gsh/transform-points (gmt/rotate-matrix 45)))
(gmt/matrix (* (mth/cos g45) 2) (* (mth/sin g45) 2) (* (- (mth/sin g45)) 4) (* (mth/cos g45) 4) 0 0))))
(t/deftest shape-has-point-pred
(let [{:keys [points] :as shape} (create-test-shape :rect {})
point1 (first points)
point2 (update point1 :x - 100)]
(t/is (true? (gsin/fast-has-point? shape point1)))
(t/is (true? (gsin/slow-has-point? shape point1)))
(t/is (false? (gsin/fast-has-point? shape point2)))
(t/is (false? (gsin/fast-has-point? shape point2)))))
;; ---- adjust-shape-flips (via apply-transform / transform-shape) ----
(t/deftest flip-x-only-toggles-flip-x-and-negates-rotation
(t/testing "Flipping only X axis toggles flip-x and negates rotation"
;; Build a rect with a known rotation, then apply a scale(-1, 1)
;; from the left edge to simulate an X-axis flip.
(let [shape (create-test-shape :rect {:rotation 30})
;; Flip horizontally about x=0 (left edge of shape)
origin (gpt/point (get-in shape [:selrect :x]) (get-in shape [:selrect :y]))
mods (ctm/resize-modifiers (gpt/point -1 1) origin)
result (gsh/transform-shape shape mods)]
;; flip-x should have been toggled (from nil/false to true)
(t/is (true? (:flip-x result)))
;; flip-y should NOT be set
(t/is (not (true? (:flip-y result))))
;; rotation is negated then normalised into [0,360): -30 mod 360 = 330
(t/is (mth/close? 330 (:rotation result))))))
(t/deftest flip-y-only-toggles-flip-y-and-negates-rotation
(t/testing "Flipping only Y axis toggles flip-y and negates rotation"
(let [shape (create-test-shape :rect {:rotation 45})
origin (gpt/point (get-in shape [:selrect :x]) (get-in shape [:selrect :y]))
mods (ctm/resize-modifiers (gpt/point 1 -1) origin)
result (gsh/transform-shape shape mods)]
(t/is (not (true? (:flip-x result))))
(t/is (true? (:flip-y result)))
;; -45 mod 360 = 315
(t/is (mth/close? 315 (:rotation result))))))
(t/deftest flip-both-axes-toggles-both-flags-but-preserves-rotation
(t/testing "Flipping both axes toggles flip-x and flip-y, but does NOT negate rotation"
;; Two simultaneous axis flips = 180° rotation, so stored rotation is unchanged.
(let [shape (create-test-shape :rect {:rotation 30})
origin (gpt/point (get-in shape [:selrect :x]) (get-in shape [:selrect :y]))
mods (ctm/resize-modifiers (gpt/point -1 -1) origin)
result (gsh/transform-shape shape mods)]
(t/is (true? (:flip-x result)))
(t/is (true? (:flip-y result)))
;; rotation must not be negated when both axes are flipped
(t/is (mth/close? 30 (:rotation result))))))
(t/deftest a-right-angle-turn-does-not-invent-a-flip-from-roundoff
(doseq [size [0.01 100 1000000]]
(let [shape (create-test-shape :rect {:width size :height size :rotation 90})
shape (assoc shape :points [(gpt/point size 0) (gpt/point size size)
(gpt/point 0 size) (gpt/point 0 (* size 1e-14))])
turn (gmt/transform-in (gpt/point (/ size 2) (/ size 2)) (gmt/rotate-matrix 90))
after (gsh/apply-transform (assoc-in shape [:modifiers :rotation] 90) turn)]
(t/is (not (:flip-x after)))
(t/is (not (:flip-y after)))
(t/is (mth/close? 180 (:rotation after))))))
(t/deftest a-reflection-keeps-flags-and-rotation-consistent-with-the-transform
;; At odd multiples of 45 degrees a reflection turns both edges by a
;; right angle, so neither edge reverses.
(doseq [angle [30 45 135 225 315]
axis [(gpt/point -1 1) (gpt/point 1 -1)]]
(let [shape (create-test-shape :rect {:width 120 :height 140})
rotated (gsh/transform-shape shape (ctm/rotation-modifiers shape (gsh/shape->center shape) angle))
after (gsh/transform-shape rotated (ctm/resize-modifiers axis (gsh/shape->center rotated)))
scale (gpt/point (if (:flip-x after) -1 1) (if (:flip-y after) -1 1))
implied (gmt/multiply (gmt/rotate-matrix (:rotation after)) (gmt/scale-matrix scale))]
(t/is (not= (boolean (:flip-x after)) (boolean (:flip-y after))) (str angle " " axis))
(t/is (every? #(mth/close? (get implied %) (get (:transform after) %) 1e-9) [:a :b :c :d])
(str angle " " axis)))))