bug#70093: *** SPAM *** bug#70093: Remove unnecessary `image-tests--map-equal'

[David Ponce via "Bug reports for GNU Emacs, the Swiss army knife of text editors" <bug-gnu-emacs@gnu.org>]

[...]> But these 2 tests fails:
> 
> 1.
>      (setf (image-property image :scale) 1)
>      (setf (image-property image :rotation) 90)
>      (should (equal (image--compute-map image)
>                                      rotated-map))
> 
>      ;; Return
>      ((((circle (199 . 41) . 24) "a" (help-echo "A"))
>       ((rect (79 . 5) 127 . 77) "b" (help-echo "B"))
>       ((poly . [199 161 206 160 213 154 218 146 221 136 223 125 221 114 218 104 213 96 206 91 199 89 191 91 185 96 179 104 176 114 175 125 176 136 179 146 185 154 191 160]) "c" (help-echo "C")))
>      ;; Instead of
>      (((circle (126 . 41) . 24) "a" (help-echo "A"))
>       ((rect (6 . 5) 54 . 77) "b" (help-echo "B"))
>       ((poly . [126 161 133 160 140 154 145 146 148 136 150 125 148 114 145 104 140 96 133 91 126 89 118 91 112 96 106 104 103 114 102 125 103 136 106 146 112 154 118 160]) "c" (help-echo "C"))))
>      ;; All the result X coords are different, but Y coords are expected.
> 
> 2.
>      (setf (image-property image :rotation) 0)
>      (setf (image-property image :flip) t)
>      (should (equal (image--compute-map image)
>                                      flipped-map))
> 
>      ;; Return
>      ((((circle (205 . 29) . 24) "a" (help-echo "A"))
>       ((rect (169 . 101) 241 . 149) "b" (help-echo "B"))
>       ((poly . [85 29 86 22 92 15 100 10 110 7 121 5 132 7 142 10 150 15 155 22 157 29 155 37 150 43 142 49 132 52 121 53 110 52 100 49 92 43 86 37]) "c" (help-echo "C")))
>      ;; Instead of
>      (((circle (125 . 29) . 24) "a" (help-echo "A"))
>       ((rect (89 . 101) 161 . 149) "b" (help-echo "B"))
>       ((poly . [5 29 6 22 12 15 20 10 30 7 41 5 52 7 62 10 70 15 75 22 77 29 75 37 70 43 62 49 52 52 41 53 30 52 20 49 12 43 6 37]) "c" (help-echo "C"))))
>      ;; All the result X coords are different, but Y coords are expected.
> 
> On my laptop:
> 
>    (image-size (image--image-without-parameters image) t) => (228 . 246)
> 
> Hope it will help to understand the reason.
[...]

Hello,

I am still trying to understand why the 2 tests above fails with my configuration.
 From the test `image--compute-map-and-original-map' I wrote the below equivalent
code to be evaled in the *scratch* buffer, in order to observe and analyze the
results interactively.  The shapes are derived from the hot spots coordinates to
ensure a strict visual correspondance between a shape and its hot spot.

On my configuration, all the computed map from the different image variations are
correct.  You can test it by hovering the different produced colored shapes with
the mouse, and observe the mouse pointer and help-echo changes.

My conclusion at this point is that the values of `flipped-map' and `rotated-map'
are not correct for my configuration, but I don't know why.

If you can try the below code and observe the result on your configuration, maybe
could we get a better understanding of what is happening for the 2 tests that fail?

Thanks!

______________________________________________________________________________

(let* ((svg (svg-create "125pt" "116pt")) ;; 246px X 228px on my conf.
        (original-map
         '(((circle (41 . 29) . 24) "a" (help-echo "A"))
           ((rect (5 . 101) 77 . 149) "b" (help-echo "B"))
           ((poly . [ 161 29 160 22 154 15 146 10 136 7 125 5 114 7
                      104 10 96 15 91 22 89 29 91 37 96 43 104 49
                      114 52 125 53 136 52 146 49 154 43 160 37])
            "c" (help-echo "C"))))
        (scaled-map
         '(((circle (82 . 58) . 48) "a" (help-echo "A"))
           ((rect (10 . 202) 154 . 298) "b" (help-echo "B"))
           ((poly . [ 322 58 320 44 308 30 292 20 272 14 250 10 228 14
                      208 20 192 30 182 44 178 58 182 74 192 86 208 98
                      228 104 250 106 272 104 292 98 308 86 320 74])
            "c" (help-echo "C"))))
        (flipped-map
         '(((circle (125 . 29) . 24) "a" (help-echo "A"))
           ((rect (89 . 101) 161 . 149) "b" (help-echo "B"))
           ((poly . [ 5 29 6 22 12 15 20 10 30 7 41 5 52 7 62 10 70 15
                      75 22 77 29 75 37 70 43 62 49 52 52 41 53 30 52
                      20 49 12 43 6 37])
            "c" (help-echo "C"))))
        (rotated-map
         '(((circle (126 . 41) . 24) "a" (help-echo "A"))
           ((rect (6 . 5) 54 . 77) "b" (help-echo "B"))
           ((poly . [ 126 161 133 160 140 154 145 146 148 136 150 125
                      148 114 145 104 140 96 133 91 126 89 118 91
                      112 96 106 104 103 114 102 125 103 136 106 146
                      112 154 118 160])
            "c" (help-echo "C"))))
        (scaled-rotated-flipped-map
         '(((circle (58 . 82) . 48) "a" (help-echo "A"))
           ((rect (202 . 10) 298 . 154) "b" (help-echo "B"))
           ((poly . [ 58 322 44 320 30 308 20 292 14 272 10 250 14 228
                      20 208 30 192 44 182 58 178 74 182 86 192 98 208
                      104 228 106 250 104 272 98 292 86 308 74 320])
            "c" (help-echo "C"))))
        )
   (svg-rectangle svg 5 101 (- 77 5) (- 149 101)
                  :stroke-width 0 :fill "red")
   (svg-circle    svg 41 29 24
                  :stroke-width 0 :fill "green")
   (svg-polyline  svg '((161 . 29) (160 . 22) (154 . 15) (146 . 10)
                        (136 . 7) (125 . 5) (114 . 7) (104 . 10)
                        (96 . 15) (91 . 22) (89 . 29) (91 . 37)
                        (96 . 43) (104 . 49) (114 . 52) (125 . 53)
                        (136 . 52) (146 . 49) (154 . 43) (160 . 37))
                  :stroke-width 0 :fill "blue")
   (let ((image (svg-image svg :map scaled-rotated-flipped-map
                           :scale 2 :rotation 90 :flip t)))
     ;; Test that `image--compute-original-map' correctly generates
     ;; original-map when creating an already transformed image.
     (insert
      (format
       "\n:flip %s :rotation %s :scale %s (equal :original-map original-map)=>%s"
       (image-property image :flip)
       (image-property image :rotation)
       (image-property image :scale)
       (equal (image-property image :original-map)
              original-map)))
     (print image)
     (insert-image image)
     
     (setf (image-property image :flip) nil)
     (setf (image-property image :rotation) 0)
     (setf (image-property image :scale) 2)
     (let ((map (image--compute-map image)))
       (insert
        (format
         "\n:flip %s :rotation %s :scale %s (equal map scaled-map)=>%s"
         (image-property image :flip)
         (image-property image :rotation)
         (image-property image :scale)
         (equal map scaled-map)))
       (setf (image-property image :map) map)
       (print image)
       ;; insert a new image in current buffer.
       (insert-image (copy-tree image t))
       )

     (setf (image-property image :scale) 1)
     (setf (image-property image :rotation) 90)
     (let ((map (image--compute-map image)))
       (insert
        (format
         "\n:flip %s :rotation %s :scale %s (equal map rotated-map)=>%s"
         (image-property image :flip)
         (image-property image :rotation)
         (image-property image :scale)
         (equal map rotated-map)))
       (setf (image-property image :map) map)
       (print image)
       ;; insert a new image in current buffer.
       (insert-image (copy-tree image t))
       )

     (setf (image-property image :rotation) 0)
     (setf (image-property image :flip) t)
     (let ((map (image--compute-map image)))
       (insert
        (format
         "\n:flip %s :rotation %s :scale %s (equal map flipped-map)=>%s"
         (image-property image :flip)
         (image-property image :rotation)
         (image-property image :scale)
         (equal map flipped-map)))
       (setf (image-property image :map) map)
       (print image)
       ;; insert a new image in current buffer.
       (insert-image (copy-tree image t))
       )

     (setf (image-property image :scale) 2)
     (setf (image-property image :rotation) 90)
     (let ((map (image--compute-map image)))
       (insert
        (format
         "\n:flip %s :rotation %s :scale %s (equal map scaled-rotated-flipped-map)=>%s"
         (image-property image :flip)
         (image-property image :rotation)
         (image-property image :scale)
         (equal map scaled-rotated-flipped-map)))
       (setf (image-property image :map) map)
       (print image)
       ;; insert a new image in current buffer.
       (insert-image (copy-tree image t))
       )
     ))