RFX-GIMP

Artifact Content
Login

Artifact 20ccf1c1f3ee184d120ef5787c5d59448e80caca:


Script file generated from LiVES

<define>
|1.7
</define>

<name>
cartoonize
</name>

<version>
2
</version>

<author>
saulgoode|
</author>

<description>
Cartoonize|Converting to cartoon|1|1|
</description>

<requires>
gimp
</requires>

<params>
edge-thickness|Edge Thickness|num0|0|0|10|
edge-intensity|Edge Intensity|num0|80|0|100|5|
quantize|Number of Colors|num0|10|0|255|
smoothing|Smoothing|num0|5|0|100|
black-threshold|Black Threshold|num0|36|0|255|
</params>

<param_window>
</param_window>

<properties>
0x0001
</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) ))))
  }
  );
</pre>

<loop>
# $p0 - Edge thickness (0-10) [0]
# $p1 - Edge intensity (0-100) [80]
# $p2 - Posterize (# colors) [10]
# $p3 - Smoothing [5]
# $p4 - Black threshold [36]

&rfx_sendmsg (
  qq{
    (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))) )
      (gimp-image-undo-disable image)
      (let ((buffer (car (gimp-edit-named-copy layer "orig")))
            (retinex-layer (car (gimp-layer-copy layer TRUE)))
            (retinex-mask 0)
            (edge-layer 0) )
        (unless (zero? $p2)
          (unless (zero? $p3)
            (plug-in-gauss RUN-NONINTERACTIVE image layer $p3 $p3 0) )
          (gimp-image-convert-indexed image NO-DITHER  MAKE-PALETTE $p2 FALSE FALSE "")
          (gimp-image-convert-rgb image) )
        (gimp-image-add-layer image retinex-layer 0)
        (plug-in-retinex RUN-NONINTERACTIVE image retinex-layer 16 3 0 0.1)
        (set! retinex-mask (car (gimp-layer-create-mask retinex-layer 0)))
        (gimp-layer-add-mask retinex-layer retinex-mask)
        (gimp-floating-sel-anchor (car (gimp-edit-named-paste retinex-mask buffer TRUE)))
        (unless (zero? $p4)
          (gimp-threshold retinex-mask $p4 255)
          (plug-in-gauss RUN-NONINTERACTIVE image retinex-mask (* 0.01 $width) (* 0.01 $width) 0) )
        (gimp-layer-remove-mask retinex-layer MASK-APPLY)
        (gimp-buffer-delete buffer)
        (gimp-layer-set-mode retinex-layer VALUE-MODE)
        (set! edge-layer (car (gimp-layer-copy (car (gimp-image-merge-down image retinex-layer CLIP-TO-IMAGE)) TRUE)))
        (gimp-image-add-layer image edge-layer 0)
        (plug-in-gauss RUN-NONINTERACTIVE image edge-layer 2.0 2.0 0)
        (plug-in-laplace RUN-NONINTERACTIVE image edge-layer)
        (plug-in-despeckle RUN-NONINTERACTIVE image edge-layer 1 1 0 255)
        (unless (zero? $p0)
          (plug-in-vpropagate RUN-NONINTERACTIVE image edge-layer
                              6 ; propagate-mode 
                              3 ; propagating-channel 
                              (/ $p0 10) ; propagating-rate 
                              15 ; direction-mask 
                              0 ; lower-limit 
                              255 ; upper-limit
                              ))
        (gimp-layer-set-opacity edge-layer $p1)
        (gimp-desaturate-full edge-layer 1) )
      (gimp-image-flatten image)
      (rfx-save-frame image "$out") )
    }
  );

</loop>

<post>
</post>

<onchange>
</onchange>