RFX-GIMP

Artifact Content
Login

Artifact e944a35413cb02d1f91644273e86823ea8b7871d:


Script file generated from LiVES

<define>
|1.7
</define>

<name>
jigsaw
</name>

<version>
1
</version>

<author>
saulgoode|http://chiselapp.com/user/saulgoode/repository/RFX-GIMP/home
</author>

<description>
Jigsaw|jigsaw transitioning|1|2|
</description>

<requires>
gimp
</requires>

<params>
horiz_pieces|Horizontal pieces|num0|0|0|1000000|
vert_pieces|Vertical pieces|num0|0|0|1000000|
curvey_edges|Curvey edges|bool|0|
clip_position|Clipboard positioning|string_list|0|Normal|Centered|Scaled|
</params>

<param_window>
layout|p0|p1|
layout|p2|
layout|hseparator|
layout|p3|p4|
</param_window>

<properties>
0x0000
</properties>

<language_code>
0xF0
</language_code>

<pre>
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 3 or higher
# as published by the Free Software Foundation.

use IO::Socket; 
use Text::Balanced;

if ($ENV{'RFXGIMP_PORT'}) {
  $rfx_port = $ENV{'RFXGIMP_PORT'};
  }
else {
  $rfx_port = 10008; 
  }

$sock = new IO::Socket::INET ( PeerAddr => 'localhost', 
                               PeerPort => $rfx_port, 
                               Proto => 'tcp' 
                               );
if ( not defined $sock ) {
  my $rfx_pid = fork();
  if (not defined $rfx_pid) {
    &sig_error("UNABLE TO EXECUTE GIMP: Not enough resources");
    } 
  elsif ($rfx_pid == 0) {
    if ( -f $tmpdir . "rfxgimp.pid") {
      open(PIDFILE, $tmpdir . "rfxgimp.pid");
      # should probably do some sanity checking for the off chance that
      # the PID has been recycled or the system has rebooted (e.g, check
      # if process was executed with /usr/bin/perl. But for now...
      kill(15, -<PIDFILE>); # the negative PID means kill all children, too.
      close(PIDFILE);
      }
    setpgid($$,0); # change the pgroup to this forked process, rather than
                   # the original LiVES (so that we don't kill LiVES when 
                   # this prgroup is killed).
    open(PIDFILE, ">" . $tmpdir . "rfxgimp.pid"); # overwrite old file
    print PIDFILE $$;
    close(PIDFILE);
    my $start_gimp = qq{ gimp -i -b "(plug-in-script-fu-server 1 $rfx_port \\\"\\\")" & };
    system ( $start_gimp ); # though started as separate process, GIMP now
                            # is part of this spawned child's pgroup, not the LiVES pgroup
    sleep(); # do nothing, forever
    &sig_error("GIMP killed by external process\n");
    }
  else {
    while (not defined $sock) {
      sleep (1);
      $sock = new IO::Socket::INET ( PeerAddr => 'localhost', 
                                     PeerPort => $rfx_port, 
                                     Proto => 'tcp' 
                                     );
      }
    }
  }

# Define a Perl subroutine for sending messages to the SF server and waiting
# for a response.
#
sub rfx_sendmsg {
  my $message = $_[0];
  my $len = length ($message);
  if ($len > 65535) {
    &sig_error("ERROR: script is too long for one server request: $len > 65535");
    };
  # send script to GIMP
  my $header = pack( 'an', 'G', $len);
  syswrite( $sock, $_ ) for ($header, $message);
  # wait for response
  my $rin = '';
  vec( $rin, fileno($sock), 1 ) = 1;
  select( $rin,  undef, undef, undef );    # wait (forever) for response start
  select( undef, undef, undef, .1 );       # wait a bit for response to finish
                                           #  increase wait if INVALID/INCOMPLETE RESPONSE occurs
  # response
  $len = sysread( $sock, $header, 4 ) or &sig_error("INVALID RESPONSE: empty response");
  ( $len == 4 and $header =~ /^G/ ) or &sig_error("INVALID RESPONSE: bad header");
  my $status;
  ($status, $len) = unpack( 'xCn', $header );
  my $response;
  ( sysread( $sock, $response, $len ) == $len ) or &sig_error("INCOMPLETE RESPONSE: $response");
  # exit if response is not "Success"
  if ( $status and $response =~ /^Error: Success\n/i ) {
    &sig_error("UNSUCCESSFUL EXECUTION: Script-fu error");
    }
  $status; 
  }

# define a Script-fu utility function to save frames using the PNG or JPG
# compression levels specified in 'gimprc'. 
# To specify a PNG compression level of 5, include the following line
# in gimprc:
#   (rfx-png-compression "5") 
# If not specified then a default level of "3" is assumed.
# "3" is a good choice for PNGs because higher levels double the write
# times while only offering about 15% reduction in file size.
# To specify a JPG compression level of 85, include the following line
# in gimprc:
#   (rfx-jpg-compression "85") 
# If not specified then a default level of "93" is assumed.

# NOTE: 'rfx-save-frame' DELETES the image.  
&rfx_sendmsg( qq{
  (begin
    (define rfx-curtmpdir "$curtmpdir")
    (define rfx-imgext "$img_ext")
    (unless (defined? 'rfx-save-frame)
      (define rfx-png-compression (catch #f (gimp-gimprc-query "rfx-png-compression")))
      (set! rfx-png-compression (if rfx-png-compression
                                  (string->number (car rfx-png-compression))
                                  3 ))
      (define rfx-jpg-compression (catch #f (gimp-gimprc-query "rfx-jpg-compression")))
      (set! rfx-jpg-compression (if rfx-jpg-compression
                                  (string->number (car rfx-jpg-compression))
                                  93 ))
      (define (rfx-save-frame image basename)
        (let ((filename (string-append rfx-curtmpdir DIR-SEPARATOR basename))
              (layer (car (gimp-image-get-active-layer image))) )
          (if (string-ci=? rfx-imgext ".jpg")
            (begin
              (gimp-context-push)
              (gimp-context-set-background '(6 6 6))
              (let loop ((layers (vector->list (cadr (gimp-image-get-layers image)))))
                (unless (null? layers)
                  (if (= (car layers) layer)
                    (gimp-drawable-set-visible layer TRUE)
                    (gimp-drawable-set-visible (car layers) FALSE) )
                  (loop (cdr layers)) ))
              (set! layer (car (gimp-image-flatten image)))
              (file-jpeg-save RUN-NONINTERACTIVE 
                              image 
                              layer
                              filename 
                              filename 
                              (/ rfx-jpg-compression 100)
                              0 ; smoothing 
                              1 ; optimize 
                              1 ; progressive 
                              "" ; comment 
                              0 ; subsmp (0-4)
                              1 ; baseline 
                              0 ; restart 
                              0 ;dct 
                              )
              (gimp-context-pop) )
            (begin
              (unless (zero? (car (gimp-image-base-type image)))
                (gimp-image-convert-rgb image) )
              (file-png-save2 RUN-NONINTERACTIVE 
                              image 
                              layer
                              filename 
                              filename 
                              FALSE ; interlace
                              rfx-png-compression
                              FALSE ; bkgd
                              (car (gimp-drawable-has-alpha layer))
                              FALSE ; offs
                              FALSE ; phys
                              FALSE ; time
                              TRUE  ; comment
                              FALSE ; svtrans
                              )))
          (gimp-image-delete image) )))
    (define (make-progressor start delta . period)
      (let ((start start)
            (value start)
            (delta delta)
            (period (if (null? period)
                        #f
                        (car period)) ))
        (lambda ()
          (let ((temp value))
            (set! value (if (and period (>= (+ value delta) (+ start period)))
                          (- (+ value delta) period)
                          (+ value delta) ))
            temp ))))
    )
  }
  );
</pre>

<loop>
# $p0 - Horizontal pieces
# $p1 - Vertical pieces
# $p2 - Curved edges (boolean)
# $p3 - Clipboard position (normal, centered, scaled)

&rfx_sendmsg (
  qq{
    (begin
      (when (= $frame $start)
        (define rfx-jigsaw-pieces '())
        (define rfx-jigsaw-keyframes '())
        (let* ((jigsaw-image (car (gimp-image-new $width $height RGB)))
               (layer (car (gimp-layer-new jigsaw-image 
                                           $width 
                                           $height 
                                           RGBA-IMAGE
                                           "jigsaw"
                                           100
                                           NORMAL-MODE ))))
          (gimp-image-add-layer jigsaw-image layer 0)
          (gimp-drawable-fill layer WHITE-FILL)
          (plug-in-jigsaw RUN-NONINTERACTIVE jigsaw-image layer $p0 $p1 $p2 0 0)
          (let row-loop ((row $p1))
            (unless (zero? row)
              (let col-loop ((col $p0))
                (if (zero? col)
                  (row-loop (pred row))
                  (begin
                    (gimp-fuzzy-select layer 
                                       (- (* (/ $width $p0) col) (/ $width $p0 2))
                                       (- (* (/ $height $p1) row) (/ $height $p1 2))
                                       128 
                                       CHANNEL-OP-REPLACE
                                       FALSE
                                       FALSE
                                       0
                                       FALSE )
                    (plug-in-sel2path RUN-NONINTERACTIVE jigsaw-image layer)
                    (set! rfx-jigsaw-pieces 
                          (cons (car (gimp-vectors-export-to-string 
                                         jigsaw-image 
                                         (car (gimp-image-get-active-vectors jigsaw-image)) ))
                                rfx-jigsaw-pieces ))
                    (col-loop (pred col)) )))))
          (gimp-image-delete jigsaw-image) 
          )
        ;; randomize the list of pieces
        (let ((number-of-pieces (* $p0 $p1)))
          (set! rfx-jigsaw-pieces 
                (let loop ((lis rfx-jigsaw-pieces)
                           (k number-of-pieces) )
                  (if (zero? k)
                    lis
                    (let ((index (random number-of-pieces)))
                      (loop (append (list-tail lis index)
                                    (list-tail (reverse lis) (- (length lis)  index)) )
                            (pred k) ))))))
        (let ((next-keyframe (make-progressor $start (/ (- $end $start) (succ (* $p0 $p1))))))
          (next-keyframe) ; start with fully shown clipboard
          (set! rfx-jigsaw-keyframes (map next-keyframe rfx-jigsaw-pieces))
          )
        )
      (let* ((input-file (string-append "$curtmpdir" DIR-SEPARATOR "$in"))
             (image (car (gimp-file-load RUN-NONINTERACTIVE input-file input-file)))
             (layer (car (gimp-image-get-active-layer image)))
             (input-file2 (string-append "$in2"))
             (image2 (car (gimp-file-load RUN-NONINTERACTIVE input-file2 input-file2)))
             (b-layer (car (gimp-layer-new-from-drawable 
                                (car (gimp-image-get-active-layer image2)) 
                                image ))) )
        (gimp-image-undo-disable image)
        (gimp-image-add-layer image b-layer 1)
        (cond 
          ((= $p3 1) ; centered
            (gimp-layer-set-offsets b-layer 
                                    (/ (- $width (car (gimp-drawable-width b-layer))) 2)
                                    (/ (- $height (car (gimp-drawable-height b-layer))) 2) ))
          ((= $p3 2) ; scaled
            (gimp-layer-scale-full b-layer $width $height TRUE INTERPOLATION-CUBIC)
            (gimp-layer-set-offsets b-layer 0 0) ))
        
        (gimp-image-delete image2)

        (gimp-layer-add-alpha layer)
        (gimp-selection-none image)

        (let loop ((number-of-keyframes (length rfx-jigsaw-keyframes))
                   (pieces rfx-jigsaw-pieces) )
          (unless (zero? number-of-keyframes)
            (let ((path (vector-ref (cadr (gimp-vectors-import-from-string image 
                                                              (car pieces)
                                                              -1
                                                              TRUE
                                                              FALSE ))
                                    0 )))
              (gimp-vectors-to-selection path CHANNEL-OP-ADD TRUE FALSE 0 0)
              (loop (pred number-of-keyframes)
                    (cdr pieces) ))))
        (gimp-selection-grow image 1)
        (if (pair? rfx-jigsaw-keyframes)
          (gimp-edit-clear layer) )
        (when (and (pair? rfx-jigsaw-keyframes)
                   (>= $frame (car rfx-jigsaw-keyframes)) )
          (set! rfx-jigsaw-keyframes (cdr rfx-jigsaw-keyframes)) )

        (gimp-image-merge-visible-layers image CLIP-TO-IMAGE)
        (rfx-save-frame image "$out") 
        )
      )
    }
  );
</loop>

<post>
</post>

<onchange>
init|$p0_max = 50;
init|$p1_max = 50;
init|$p0 = 3;
init|$p1 = 3;
</onchange>