← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to plug-ins/script-fu/scripts/blend-anim.scm

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/script-fu/scripts/blend-anim.scm
1
 
; The GIMP -- an image manipulation program
 
1
; GIMP - The GNU Image Manipulation Program
2
2
; Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
 
; 
 
3
;
4
4
; This program is free software; you can redistribute it and/or modify
5
5
; it under the terms of the GNU General Public License as published by
6
6
; the Free Software Foundation; either version 2 of the License, or
7
 
; (at your option) any later version.  
8
 
; 
 
7
; (at your option) any later version.
 
8
;
9
9
; This program is distributed in the hope that it will be useful,
10
10
; but WITHOUT ANY WARRANTY; without even the implied warranty of
11
11
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
12
; GNU General Public License for more details.
13
 
; 
 
13
;
14
14
; You should have received a copy of the GNU General Public License
15
15
; along with this program; if not, write to the Free Software
16
16
; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
26
; 1.03 - only call blur plugin when blut-radius >= 1.0
27
27
;
28
28
; Copyright (C) 1997-1999 Sven Neumann <sven@gimp.org>
29
 
;  
 
29
;
30
30
;
31
31
; Blends two or more layers over a backgound, so that an animation can
32
32
; be saved. A minimum of three layers is required.
33
33
 
34
 
(define (multi-raise-layer image layer times)
35
 
  (while (> times 0)
36
 
     (gimp-image-raise-layer image layer)
37
 
     (set! times (- times 1))))
38
 
           
39
 
  
40
34
(define (script-fu-blend-anim img
41
 
                              drawable
42
 
                              frames
43
 
                              max-blur
44
 
                              looped)
45
 
  (let* ((max-blur (max max-blur 0))
46
 
         (frames (max frames 0))
47
 
         (image (car (gimp-image-duplicate img)))
48
 
         (width (car (gimp-image-width image)))
49
 
         (height (car (gimp-image-height image)))
50
 
         (layers (gimp-image-get-layers image))
51
 
         (num-layers (car layers))
52
 
         (layer-array (cadr layers))
53
 
         (slots (- num-layers 2))
54
 
         (bg-layer (aref layer-array (- num-layers 1)))
55
 
         (max-width 0)
56
 
         (max-height 0)
57
 
         (offset-x 0)
58
 
         (offset-y 0))
59
 
        
60
 
  (if (> num-layers 2)
61
 
      (begin
62
 
 
63
 
        (gimp-image-undo-disable image)
64
 
 
65
 
        (if (= looped TRUE)
66
 
            ; add a copy of the lowest blend layer on top 
67
 
            (let* ((copy (car (gimp-layer-copy
68
 
                               (aref layer-array (- num-layers 2)) TRUE))))
69
 
              (gimp-image-add-layer image copy 0)
70
 
              (set! layers (gimp-image-get-layers image))
71
 
              (set! num-layers (car layers))
72
 
              (set! layer-array (cadr layers))
73
 
              (set! slots (- num-layers 2))
74
 
              (set! bg-layer (aref layer-array (- num-layers 1)))))
75
 
 
76
 
        ; make all layers invisible and check for sizes
77
 
        (let* ((min-offset-x width)
78
 
               (min-offset-y height)
79
 
               (layer-count slots))
80
 
          (gimp-drawable-set-visible bg-layer FALSE)
81
 
          (while (> layer-count -1)
82
 
             (let* ((layer (aref layer-array layer-count))
83
 
                    (layer-width (+ (car (gimp-drawable-width layer))
84
 
                                    (* max-blur 2)))
85
 
                    (layer-height (+ (car (gimp-drawable-height layer))
86
 
                                     (* max-blur 2)))
87
 
                    (layer-offsets (gimp-drawable-offsets layer))
88
 
                    (layer-offset-x (- (car layer-offsets) max-blur))
89
 
                    (layer-offset-y (- (cadr layer-offsets) max-blur)))
90
 
               (gimp-drawable-set-visible layer FALSE)
91
 
               (set! max-width (max max-width layer-width))
92
 
               (set! max-height (max max-height layer-height))
93
 
               (set! min-offset-x (min min-offset-x layer-offset-x))
94
 
               (set! min-offset-y (min min-offset-y layer-offset-y))
95
 
               (set! layer-count (- layer-count 1))))
96
 
          (set! offset-x (- (car (gimp-drawable-offsets bg-layer))
97
 
                            min-offset-x))
98
 
          (set! offset-y (- (cadr (gimp-drawable-offsets bg-layer))
99
 
                            min-offset-y)))
100
 
        
101
 
        ; create intermediate frames by merging copies of adjascent layers 
102
 
        ; with the background layer 
103
 
        (let* ((layer-count slots))
104
 
          (while (> layer-count 0)
105
 
             (let* ((frame-count frames)
106
 
                    (lower-layer (aref layer-array layer-count))
107
 
                    (upper-layer (aref layer-array (- layer-count 1))))
108
 
               (while (> frame-count 0)
109
 
                  (let* ((opacity (* (/ frame-count (+ frames 1)) 100))
110
 
                         (blur (/ (* opacity max-blur) 100))
111
 
                         (upper-copy (car (gimp-layer-copy upper-layer TRUE)))
112
 
                         (lower-copy (car (gimp-layer-copy lower-layer TRUE)))
113
 
                         (bg-copy (car (gimp-layer-copy bg-layer TRUE))))
114
 
                    (gimp-image-add-layer image bg-copy 0)
115
 
                    (gimp-image-add-layer image lower-copy 0)
116
 
                    (gimp-image-add-layer image upper-copy 0)
117
 
                    (gimp-drawable-set-visible upper-copy TRUE)
118
 
                    (gimp-drawable-set-visible lower-copy TRUE)
119
 
                    (gimp-drawable-set-visible bg-copy TRUE)
120
 
                    (gimp-layer-set-opacity upper-copy (- 100 opacity))
121
 
                    (gimp-layer-set-opacity lower-copy opacity)
122
 
                    (gimp-layer-set-opacity bg-copy 100)
123
 
                    (if (> max-blur 0)
124
 
                        (let* ((layer-width (car (gimp-drawable-width upper-copy)))
125
 
                               (layer-height (car (gimp-drawable-height upper-copy))))
126
 
                          (gimp-layer-set-preserve-trans upper-copy FALSE)
127
 
                          (gimp-layer-resize upper-copy
128
 
                                             (+ layer-width (* blur 2))
129
 
                                             (+ layer-height (* blur 2))
130
 
                                             blur
131
 
                                             blur)
132
 
                          (if (>= blur 1.0)
133
 
                              (plug-in-gauss-rle 1
134
 
                                                 image
135
 
                                                 upper-copy
136
 
                                                 blur
137
 
                                                 TRUE TRUE))
138
 
                          (set! blur (- max-blur blur))
139
 
                          (gimp-layer-set-preserve-trans lower-copy FALSE)
140
 
                          (set! layer-width (car (gimp-drawable-width
141
 
                                                  lower-copy)))
142
 
                          (set! layer-height (car (gimp-drawable-height
143
 
                                                   lower-copy)))
144
 
                          (gimp-layer-resize lower-copy
145
 
                                             (+ layer-width (* blur 2))
146
 
                                             (+ layer-height (* blur 2))
147
 
                                             blur
148
 
                                             blur)
149
 
                          (if (>= blur 1.0)
150
 
                              (plug-in-gauss-rle 1
151
 
                                                 image
152
 
                                                 lower-copy
153
 
                                                 blur
154
 
                                                 TRUE TRUE))))
155
 
                    (gimp-layer-resize bg-copy
156
 
                                       max-width
157
 
                                       max-height
158
 
                                       offset-x
159
 
                                       offset-y)
160
 
                    (let* ((merged-layer (car (gimp-image-merge-visible-layers
161
 
                                             image CLIP-TO-IMAGE))))
162
 
                      (gimp-drawable-set-visible merged-layer FALSE))
163
 
                    (set! frame-count (- frame-count 1))))
164
 
               (set! layer-count (- layer-count 1)))))
165
 
        
166
 
        ; merge all original blend layers but the lowest one 
167
 
        ; with copies of the background layer 
168
 
        (let* ((layer-count 0))
169
 
          (while (< layer-count slots)
170
 
             (let* ((orig-layer (aref layer-array layer-count))
171
 
                    (bg-copy (car (gimp-layer-copy bg-layer TRUE))))
172
 
               (gimp-image-add-layer image
173
 
                                     bg-copy
174
 
                                     (* layer-count (+ frames 1)))
175
 
               (multi-raise-layer image
176
 
                                  orig-layer
177
 
                                  (+ (* (- slots layer-count) frames) 1))
178
 
               (gimp-drawable-set-visible orig-layer TRUE)
179
 
               (gimp-drawable-set-visible bg-copy TRUE)
180
 
               (gimp-layer-resize bg-copy
181
 
                                  max-width
182
 
                                  max-height
183
 
                                  offset-x
184
 
                                  offset-y)
185
 
               (let* ((merged-layer (car (gimp-image-merge-visible-layers
186
 
                                        image CLIP-TO-IMAGE))))
187
 
                 (gimp-drawable-set-visible merged-layer FALSE))
188
 
               (set! layer-count (+ layer-count 1)))))
189
 
        
190
 
        ; merge the lowest blend layer with the background layer  
191
 
        (let* ((orig-layer (aref layer-array (- num-layers 2))))
192
 
          (gimp-drawable-set-visible bg-layer TRUE)
193
 
          (gimp-drawable-set-visible orig-layer TRUE)
194
 
          (gimp-image-merge-visible-layers image CLIP-TO-IMAGE))
195
 
        
196
 
        ; make all layers visible again
197
 
        (let* ((result-layers (gimp-image-get-layers image))
198
 
               (num-result-layers (car result-layers))
199
 
               (result-layer-array (cadr result-layers))
200
 
               (layer-count (- num-result-layers 1)))
201
 
          (while (> layer-count -1)
202
 
             (let* ((layer (aref result-layer-array layer-count))
203
 
                    (name (string-append "Frame "
204
 
                                         (number->string
205
 
                                          (- num-result-layers layer-count) 10))))
206
 
               (gimp-drawable-set-visible layer TRUE)
207
 
               (gimp-drawable-set-name layer name)
208
 
               (set! layer-count (- layer-count 1))))
209
 
        
210
 
          (if (= looped TRUE)
211
 
              ; remove the topmost layer
212
 
              (gimp-image-remove-layer image (aref result-layer-array 0))))
213
 
              
214
 
        (gimp-image-undo-enable image)
215
 
        (gimp-display-new image)
216
 
        (gimp-displays-flush))
217
 
  (gimp-message "Blend Animation needs at least three source layers"))))
 
35
                              drawable
 
36
                              frames
 
37
                              max-blur
 
38
                              looped)
 
39
 
 
40
  (define (multi-raise-layer image layer times)
 
41
    (while (> times 0)
 
42
       (gimp-image-raise-layer image layer)
 
43
       (set! times (- times 1))
 
44
    )
 
45
  )
 
46
 
 
47
  (let* (
 
48
        (max-blur (max max-blur 0))
 
49
        (frames (max frames 0))
 
50
        (image (car (gimp-image-duplicate img)))
 
51
        (width (car (gimp-image-width image)))
 
52
        (height (car (gimp-image-height image)))
 
53
        (layers (gimp-image-get-layers image))
 
54
        (num-layers (car layers))
 
55
        (layer-array (cadr layers))
 
56
        (slots (- num-layers 2))
 
57
        (bg-layer (aref layer-array (- num-layers 1)))
 
58
        (max-width 0)
 
59
        (max-height 0)
 
60
        (offset-x 0)
 
61
        (offset-y 0)
 
62
        )
 
63
 
 
64
    (if (> num-layers 2)
 
65
        (begin
 
66
                  (gimp-image-undo-disable image)
 
67
 
 
68
                  (if (= looped TRUE)
 
69
                          ; add a copy of the lowest blend layer on top
 
70
                          (let* ((copy (car (gimp-layer-copy
 
71
                                                 (aref layer-array (- num-layers 2)) TRUE))))
 
72
                                (gimp-image-add-layer image copy 0)
 
73
                                (set! layers (gimp-image-get-layers image))
 
74
                                (set! num-layers (car layers))
 
75
                                (set! layer-array (cadr layers))
 
76
                                (set! slots (- num-layers 2))
 
77
                                (set! bg-layer (aref layer-array (- num-layers 1)))))
 
78
 
 
79
                  ; make all layers invisible and check for sizes
 
80
                  (let* ((min-offset-x width)
 
81
                                 (min-offset-y height)
 
82
                                 (layer-count slots))
 
83
                        (gimp-drawable-set-visible bg-layer FALSE)
 
84
                        (while (> layer-count -1)
 
85
                                   (let* ((layer (aref layer-array layer-count))
 
86
                                  (layer-width (+ (car (gimp-drawable-width layer))
 
87
                                                  (* max-blur 2)))
 
88
                                  (layer-height (+ (car (gimp-drawable-height layer))
 
89
                                                   (* max-blur 2)))
 
90
                                  (layer-offsets (gimp-drawable-offsets layer))
 
91
                                  (layer-offset-x (- (car layer-offsets) max-blur))
 
92
                                  (layer-offset-y (- (cadr layer-offsets) max-blur)))
 
93
                                 (gimp-drawable-set-visible layer FALSE)
 
94
                                 (set! max-width (max max-width layer-width))
 
95
                                 (set! max-height (max max-height layer-height))
 
96
                                 (set! min-offset-x (min min-offset-x layer-offset-x))
 
97
                                 (set! min-offset-y (min min-offset-y layer-offset-y))
 
98
                                 (set! layer-count (- layer-count 1))))
 
99
                        (set! offset-x (- (car (gimp-drawable-offsets bg-layer))
 
100
                                          min-offset-x))
 
101
                        (set! offset-y (- (cadr (gimp-drawable-offsets bg-layer))
 
102
                                          min-offset-y)))
 
103
 
 
104
                  ; create intermediate frames by merging copies of adjascent layers
 
105
                  ; with the background layer
 
106
                  (let* ((layer-count slots))
 
107
                        (while (> layer-count 0)
 
108
                           (let* ((frame-count frames)
 
109
                                  (lower-layer (aref layer-array layer-count))
 
110
                                  (upper-layer (aref layer-array (- layer-count 1))))
 
111
                                 (while (> frame-count 0)
 
112
                                        (let* ((opacity (* (/ frame-count (+ frames 1)) 100))
 
113
                                   (blur (/ (* opacity max-blur) 100))
 
114
                                   (upper-copy (car (gimp-layer-copy upper-layer TRUE)))
 
115
                                   (lower-copy (car (gimp-layer-copy lower-layer TRUE)))
 
116
                                   (bg-copy (car (gimp-layer-copy bg-layer TRUE))))
 
117
                                  (gimp-image-add-layer image bg-copy 0)
 
118
                                  (gimp-image-add-layer image lower-copy 0)
 
119
                                  (gimp-image-add-layer image upper-copy 0)
 
120
                                  (gimp-drawable-set-visible upper-copy TRUE)
 
121
                                  (gimp-drawable-set-visible lower-copy TRUE)
 
122
                                  (gimp-drawable-set-visible bg-copy TRUE)
 
123
                                  (gimp-layer-set-opacity upper-copy (- 100 opacity))
 
124
                                  (gimp-layer-set-opacity lower-copy opacity)
 
125
                                  (gimp-layer-set-opacity bg-copy 100)
 
126
                                  (if (> max-blur 0)
 
127
                                  (let* ((layer-width (car (gimp-drawable-width upper-copy)))
 
128
                                                 (layer-height (car (gimp-drawable-height upper-copy))))
 
129
                                        (gimp-layer-set-lock-alpha upper-copy FALSE)
 
130
                                        (gimp-layer-resize upper-copy
 
131
                                                           (+ layer-width (* blur 2))
 
132
                                                           (+ layer-height (* blur 2))
 
133
                                                           blur
 
134
                                                           blur)
 
135
                                        (if (>= blur 1.0)
 
136
                                                (plug-in-gauss-rle 1
 
137
                                                           image
 
138
                                                           upper-copy
 
139
                                                           blur
 
140
                                                           TRUE TRUE))
 
141
                                        (set! blur (- max-blur blur))
 
142
                                        (gimp-layer-set-lock-alpha lower-copy FALSE)
 
143
                                        (set! layer-width (car (gimp-drawable-width
 
144
                                                                lower-copy)))
 
145
                                        (set! layer-height (car (gimp-drawable-height
 
146
                                                                 lower-copy)))
 
147
                                        (gimp-layer-resize lower-copy
 
148
                                                           (+ layer-width (* blur 2))
 
149
                                                           (+ layer-height (* blur 2))
 
150
                                                           blur
 
151
                                                           blur)
 
152
                                        (if (>= blur 1.0)
 
153
                                                (plug-in-gauss-rle 1
 
154
                                                           image
 
155
                                                           lower-copy
 
156
                                                           blur
 
157
                                                           TRUE TRUE))))
 
158
                                  (gimp-layer-resize bg-copy
 
159
                                                         max-width
 
160
                                                         max-height
 
161
                                                         offset-x
 
162
                                                         offset-y)
 
163
                                  (let* ((merged-layer (car (gimp-image-merge-visible-layers
 
164
                                                           image CLIP-TO-IMAGE))))
 
165
                                        (gimp-drawable-set-visible merged-layer FALSE))
 
166
                                  (set! frame-count (- frame-count 1))))
 
167
                                 (set! layer-count (- layer-count 1)))))
 
168
 
 
169
                  ; merge all original blend layers but the lowest one
 
170
                          ; with copies of the background layer
 
171
                  (let* ((layer-count 0))
 
172
                        (while (< layer-count slots)
 
173
                                   (let* ((orig-layer (aref layer-array layer-count))
 
174
                                  (bg-copy (car (gimp-layer-copy bg-layer TRUE))))
 
175
                                 (gimp-image-add-layer image
 
176
                                                   bg-copy
 
177
                                                   (* layer-count (+ frames 1)))
 
178
                                 (multi-raise-layer image
 
179
                                                orig-layer
 
180
                                                (+ (* (- slots layer-count) frames) 1))
 
181
                                 (gimp-drawable-set-visible orig-layer TRUE)
 
182
                                 (gimp-drawable-set-visible bg-copy TRUE)
 
183
                                 (gimp-layer-resize bg-copy
 
184
                                                max-width
 
185
                                                max-height
 
186
                                                offset-x
 
187
                                                offset-y)
 
188
                                 (let* ((merged-layer (car (gimp-image-merge-visible-layers
 
189
                                                  image CLIP-TO-IMAGE))))
 
190
                           (gimp-drawable-set-visible merged-layer FALSE))
 
191
                           (set! layer-count (+ layer-count 1)))))
 
192
 
 
193
                  ; merge the lowest blend layer with the background layer
 
194
                  (let* ((orig-layer (aref layer-array (- num-layers 2))))
 
195
                        (gimp-drawable-set-visible bg-layer TRUE)
 
196
                        (gimp-drawable-set-visible orig-layer TRUE)
 
197
                        (gimp-image-merge-visible-layers image CLIP-TO-IMAGE))
 
198
 
 
199
                  ; make all layers visible again
 
200
                  (let* ((result-layers (gimp-image-get-layers image))
 
201
                                 (num-result-layers (car result-layers))
 
202
                                 (result-layer-array (cadr result-layers))
 
203
                                 (layer-count (- num-result-layers 1)))
 
204
                        (while (> layer-count -1)
 
205
                           (let* ((layer (aref result-layer-array layer-count))
 
206
                                  (name (string-append "Frame "
 
207
                                                   (number->string
 
208
                                                        (- num-result-layers layer-count) 10))))
 
209
                                 (gimp-drawable-set-visible layer TRUE)
 
210
                                 (gimp-drawable-set-name layer name)
 
211
                                 (set! layer-count (- layer-count 1))))
 
212
 
 
213
                        (if (= looped TRUE)
 
214
                                ; remove the topmost layer
 
215
                                (gimp-image-remove-layer image (aref result-layer-array 0))))
 
216
 
 
217
                  (gimp-image-undo-enable image)
 
218
                  (gimp-display-new image)
 
219
                  (gimp-displays-flush)
 
220
                )
 
221
 
 
222
      (gimp-message _"Blend Animation needs at least three source layers")
 
223
    )
 
224
  )
 
225
)
218
226
 
219
227
(script-fu-register "script-fu-blend-anim"
220
 
                    _"_Blend..."
221
 
                    "Blend two or more layers over a background, so that an 
222
 
                     animation can be saved"
223
 
                    "Sven Neumann <sven@gimp.org>"
224
 
                    "Sven Neumann"
225
 
                    "1999/12/21"
226
 
                    "RGB* GRAY*"
227
 
                    SF-IMAGE       "Image"               0
228
 
                    SF-DRAWABLE    "Drawable"            0
229
 
                    SF-ADJUSTMENT _"Intermediate frames" '(3 1 1024 1 10 0 1)
230
 
                    SF-ADJUSTMENT _"Max. blur radius"    '(0 0 1024 1 10 0 1)
231
 
                    SF-TOGGLE     _"Looped"              TRUE)
 
228
    _"_Blend..."
 
229
    _"Create intermediate layers to blend two or more layers over a background as an animation"
 
230
    "Sven Neumann <sven@gimp.org>"
 
231
    "Sven Neumann"
 
232
    "1999/12/21"
 
233
    "RGB* GRAY*"
 
234
    SF-IMAGE       "Image"               0
 
235
    SF-DRAWABLE    "Drawable"            0
 
236
    SF-ADJUSTMENT _"Intermediate frames" '(3 1 1024 1 10 0 1)
 
237
    SF-ADJUSTMENT _"Max. blur radius"    '(0 0 1024 1 10 0 1)
 
238
    SF-TOGGLE     _"Looped"              TRUE
 
239
)
232
240
 
233
241
(script-fu-menu-register "script-fu-blend-anim"
234
 
                         _"<Image>/Script-Fu/Animators")
 
242
                         "<Image>/Filters/Animation/Animators")