There is not all that much to it, but there is one PG-specific wrinkle (that I will get to).
The first line uses the image() function and calls it with all the parameters passed to IMAGE(). For any subroutine, the @_ array is the array of arguments that it received, and image(@_) simply passes those on to image(). It stores the result in a local variable $out (the my means that variable is local to the IMAGE() subroutine).
The last line returns the value of $out so the only thing left to understand is the second line. That line performs a "regular expression" substitution. Regular expressions (or regex) are pattern matching expressions that are used to locate specific patterns within a string, and (in this case) replace them with other values. Many programming languages include them, so they have a fairly well-know syntax, but Perl regular expressions are documented here.
This is where the PG-specific item comes into play. Regular expressions have a means of indicating special characters (like newlines and tabs) or collections of characters (like "white space" in general), and this method uses backslashes to indicate them. But PG handles backslashes specially (because they are used in TeX code) and in such a way that they don't work properly in regular expressions within a PG file. So PG provides an alternative, which is ~~.
Every ~~ you see in the IMAGE() function should be a \ in normal Perl code. So the regular expression on the second line is actually
$out =~ s/\s*([\n\t]+\s*)+|^\s+|\s+$//g;
The
=~ says apply the substitution on the right to the variable on the left (i.e., modify
$out by the regex). The
s/ indicates a substitution (as opposed to just a matching operation) is to be performed. The stuff up to the next (unescaped)
/ is the matching regular expression, and the stuff between that an the next
/ is what to replace it by. (So a substitution usually looks like
s/regex/replacement/.
In this case, the regex is \s*([\n\t]+\s*)+|^\s+|\s+$, which I will explain in a moment, and the replacement string is empty (the material between the slashes in //). The trailing g means the substitution is global, meaning every substring that matches the regex will be replaced (not just the first one).
So the upshot is that anything the matches the regex will be removes from the string (since the replacement string is empty).
So what matches this particular regex? This is where the reference I cite above comes in, but I'll explain this one now. The first thing to know is that | is used to separate sub-expressions, any one of which is allowed to be matched. So this means that there are three things that we are looking for, any one of which can be matched (i.e., all occurrences of these three patterns will be removed).
The three subexpressions are \s*([\n\t]+\s*)+, ^\s+,and \s+$. I will explain the last two first.
The caret (^) indicates the start of the string, so ^\s+ only will match something at the beginning of the string. Similarly, the dollar sign ($) matches the end of the string, so \s+$ only matches something at the end of the string. The \s indicates any white-space character (space, tab, non-breaking space, etc.), and + means that the preceding item must appear one or more times in a row. That is, ^\s+ matches all the spaces at the beginning of the string, while \s+$ matches all the spaces at the end of the string.
The regex \s*([\n\t]+\s*)+ starts with \s*. We already know \s matches while space; here the * means the preceding can match zero or more times. So this is zero or more spaces. The next part uses parentheses to group the regex [\n\t]+\s* so that + applies to that whole thing. That means one or more occurrences of stuff that matches [\n\t]+\s*. So this is [\n\t]+ followed by zero or more spaces.
The brackets are used to enclose a list of characters to match (e.g., [aeiou] would match one of the vowels), and in this case, we are matching \n and \t. These are the newline (\n) and tab (\t). So [\n\t]+ means one or more newlines or tabs, and [\n\t]+\s* means one or more newlines or tabs followed by optional spaces. Finally, ([\n\t]+\s*)+ means any number of those in a row (but at least one), and \s*([\n\t]+\s*)+ means optional spaces followed by newlines and tabs followed by optional spaces, repeated at least once.
Anything that matches any of those three patterns will be removed. So the upshot is that the second pattern removes any leading whitespace in the string, the third one removes any trailing whitespace in the string, and the first pattern removes any line breaks and the whitespace surrounding them.
So the upshot is to remove any line breaks and the whitespace around them, and any whitespace at the beginning or end of the string. This was the whitespace that was causing problems when the image was included in the pre-formatted output, since in pre-formatted output, multiple spaces and newlines are respected, while in regular formatted HTML they are collapsed to a single space.
Hope that helps.