Finti ce mo

"Solve for all possible X." [SFW] Artworks, Software, Tutorials, Rambling. Other tumblrs: [[N]SFW] (sketches, general study), [NSFW] artworks FAQ

[finticemo]

Personal development vs Technique

(x-posted from /r/ArtFundamentals )

IMO the main 'practicing bad technique' to be concerned about is : "worrying about technique". All of the really important stuff is actually personal development, eg:

Cultivating both energeticness ("sprint") and endurance ("marathon"). The former is key to creating appealing works; the latter key to finishing them.

Maintaining a clear awareness of what you are trying to do. When I keep consciously focusing on a particular theme, I naturally produce work with a consistent style. If I'm not focused, it's mediocre and generic. If I think constantly of the 3d form of things, then the result has depth. If not, it generally doesn't.

Cheerfully accepting frequent failure as the only real path to success (anything else tends to turn into techniques to disguise your inadequacies rather than address them).

Keeping track of your priorities (don't bother starting a drawing until you decide this, and don't bother continuing a drawing if you aren't clear on the 'one aspect I'm aiming to refine right now')

Practicing things you hate as well as things you like (ie. not getting stuck in your comfort zone; drawing weird subjects, using weird media, doing difficult exercises using unfamiliar techniques...)

Tracking your progress, doing a regular inventory on your skills, and of course, making sure you have an overall plan (curriculum). I made a comment here a few weeks ago that might help with this.

BTW I do not mean to imply that established techniques (perspective, color, etc) are useless. Rather, that learning techniques merely 'because they are on my list' is a bad prioritization.

Techniques will work best for you when you have struggled with the problem and decided to learn this particular technique.. because you have enough experience with the problem that you think this technique will address it. If you attempt to head your problems off by learning techniques in advance, you also head off the struggles with the problem. Those struggles, which help you personally connect to the problem, are what help you apply techniques effectively and mindfully. Failing to struggle tends to lead to superficial 'solution's : merely seeing that there is a problem and mindlessly cycling through techniques until things look better.

[finticemo]

"the most extensive treatment of linear perspective available online, and one of the most comprehensive tutorials available in any textbook currently in print"

It lives up to the summary. If there is anything at all that you are confused about about perspective, read this.

Caveat: do not read if you don't feel you have a basic grasp of perspective. It goes into such technical detail that it is likely to be offputting if you lack experience to relate it to. In that case you would be better off picking up Scott Robertson's How To Draw, or Andrew Loomis.

[finticemo]

Tracing your interactive shell sessions like !/bin/sh -x does

You know how you debug scripts by adding -x to your shbang line --> each command executed is printed out?

I just learned, you can do the same in an interactive session. Just enter set -x and all subsequent commands (including those involved in generating your prompt, be aware) will be printed as they are executed. In particular this can be very helpful when you believe a function you have defined is misbehaving.

This is compatible with zsh, bash, sh, dash, and probably others too.

To turn tracing back off, enter the somewhat counter-intuitive set +x.

These commands work equally well in a script, so you can get information about parts you are suspicious about, without being spammed the rest of the time. Obviously something to use in moderation, but extremely informative when you do choose to use it.

[finticemo]

[finticemo]

Recently implemented tiling display mode(s) in my variant of sxiv . After implementing the basic mode, I added variations that display flipped and rotated versions, to give the tile the fullest possible 'workout'

Still some bugs to iron out -- for example, animation works, but images with an alpha channel currently have a weird display.

[finticemo]

A quick tutorial showing how you can use QMask to do cutouts with the same edge quality as painting has. Here, I realize that I want to paint 'behind' a volume I've already defined -- this is why QMask is necessary. Otherwise I would simply paint over it in one step.

(I considered other methods like vector based and freehand select, but naturally it would take a lot of fiddling to make these match the brush softness. Much simpler to just use the brush to define the selection.)

[finticemo]

My GIMP-Python plugins

I've written several plugins for GIMP using GIMP-Python over time. I have just put these up on Github.

The newest of these is 'copynauto', which provides a two-key interface to GIMP's Named Buffers. It makes it easy to collect clippings from many images, tracking where they came from, and dispense them quickly where you want them in your layer structure.

In my case, I have 'copy autonamed' and 'paste latest named and delete' assigned to adjacent numeric keys (2 and 3). When I want to take a clipping, I make my selection with Rectangle tool, hit 2, and the clipping is stored (with a name indicating where it came from). I will do this several times in a row, especially if a single image contains multiple things I want to get clippings of.

Then when I want to place those clippings in the destination image, I select the layer I want to paste above, hit 3, and the latest clipping is placed there (and removed from the list of clippings). I will do this repeatedly too, until there are no more clippings I need to place. Layer names will be taken directly from clipping names, so tracking down sources is easy.

If I lose track of where I was, I bring up GIMP's Buffers dockable, which lists all named buffers.

Okay, tutorial over :)

I'll finish with a synopsis of the plugins that can currently be found in my repository:

applylayer : Iteratively 'apply paint' - merges down the content in a layer/group and then clears the content in it (without actually removing the layers themselves)

backgroundify : Add a background color/pattern to (part of) one or all layers

copynauto : Fast interface to automatically-named GIMP Named Buffers, for collaging. Quickly accumulate a set of clippings and then dispense them.

generate_colorband : Color analysis. Attempts to find and intelligently group N colors representing the layer, producing a 'color band' similar to the output of Smooth Palette. Really SLOW.

palette_to_layer_pixels : Allows editing palettes via image color operators like Curves, by.. transferring them into and out of layers.

select_layers : 'Grep' for layers. Removes layers that do/don't match a glob or Python regexp pattern.

split_rectangles : Given an input layer containing isolated rectangular areas within a transparent 'sea', extract all such rectangles as layers. Slow.

[finticemo]

Entropy-sort with Linux+ImageMagick

ImageMagick 'identify' tool, which prints information about images, has a metric called 'entropy'. This measures how unpredictable your image data is, and amounts to an approximate measure of how detailed your image is.

By combining identify with a few common Linux tools like sort and xargs, I arrived at this script which sorts a list of files (piped in on stdin) by their entropy:

#!/bin/sh # sort images by entropy level, most detailed to least detailed SORTFLAGS= if [ "$1" = "r" ]; then SORTFLAGS=-r fi sed 's/$/[0]/' | tr \\n \\0 |xargs -0 identify -format "%[entropy] %i\n"| sort $SORTFLAGS|cut -d ' ' -f 2-

I use it to help sorting scanned drawings.

Notes:

Measurement of entropy is relatively slow. Entropy sort takes about 90 seconds for a collection of 100 1700px-wide scans, on my system.

For animated or layered images like GIF or TIFF, only the first frame / layer's entropy is used. (It's possible to take the average of the frames, but a) it would be proportionally slower, b) it would probably need Python or Ack, not just basic shell script, and c) it's not particularly important IMO. So I didn't bother implementing that.)

[finticemo]

Basic ‘visible edges solid, hidden edges dashed’ Freestyle rendering in Blender

 Here’s a mini-tut sharing my experience with figuring out how to render Freestyle in Blender scenes, in this specific diagram/technical/architecture-friendly style where visible edges are shown with solid lines, and hidden edges are shown with dashed lines.

It is actually quite simple..Once you figure out how to get freestyle going (Tick Freestyle in the Render tab), and edit linesets/styles (go to the next tab, RenderLayers, Scroll down and unfold both Freestyle and Freestyle Line Set):

You start with one lineset, which you can use to render the visible edges.

Add a second lineset, which selects Hidden edges rather than Visible (in Visibility section), and enable Dashed line option (at the bottom), setting the first two numbers to 4, 4 (representing a 4px on, 4px off dash pattern).

You might also want to make sure that the base thickness of your dashed lineset is less than the main lineset (check the Thickness tab). I chose 3 for my dashed lines and 5 for my main lines.

Finally, according to the scale of the diagram, you might want Blender to reduce line opacity or size according to distance from the camera.

You can do that by adding a 'distance from camera' modifier in the Alpha tab. In my test document, I used Subtract mode with 0.5 influence, and then selected the all the objects I wanted and hit 'fill range by selection'.

I did that for both the main line style and dashed line style.

The result of the above looks like this:

And here is a version using a toon material, since that is more typical:

PS. I later decided that the dashed line fading wasn’t noticable enough, and switched to a Distance from Object modifier instead, with the object being the closest sphere. For ultimate control, I guess you would use Distance from Object with an empty designed exclusively to control line fading.

[finticemo]

Cleavage - a short essay

Cleavage relates z-buffering to lineart, particularly to creating the illusion of depth. The relevant definition of 'cleavage' here is 'a place where one form overlaps another'.

When you consider a 3d scene, some objects, and parts of objects, are in front of others. (image shows a z-depth pass from Blender)

You might naturally choose to make a line between them to show that depth.

That overlap is what largely creates the impression of depth — those lines define, more than anything else, the spatial relationships of the objects.

Once you have drawn the lines that 'sandwich' an object in space, you have effectively located it. Of course, those lines may just locate the object over the background... in this case, no illusion of depth is created. You can see easily that the implicit lines defining this cube:

.. convey a sense of gross proportion and perspective, but not a sense of scale;

Here is a comparative image of the three objects with actual lighting..

The line work holds up, but feels a little heavy handed now, detracting from the cast shadows. (note that I have only marked the object v object cleavage areas, not the object v background cleavage points. The latter are part of a complete drawing, but can be much more easily extrapolated from the former than vice versa, so are less important.

In general, where you look at the z-levels in a scene, the places where an artist puts a line are the places of higher discontinuity in Z-level, and the thickness of that line generally is proportionate to the level of discontinuity. 

Supposing there is a tree behind me, 100 meters away, and behind that and to the side, there is a house. You might place a line showing the shoulder->tree Z discontinuity (space) followed by a line showing the tree->house discontinuity, perhaps finally followed by a line showing the house -> distant horizon discontinuity. 

This also applies on a micro level — the lines in a subtly rendered rock texture mainly show where there are sharp drops or rises. These are the parts of an image that stand out to our vision. The small elements operate in the same way as the large. Try to consider a rock or a human body as just another kind of landscape.. it is the overlap that does a majority of the communicating what something -is-. Even an ant is a vast vista.

To summarize: Providing you possess competence in breaking down volumes and understanding perspective, marking object v object cleavage lines in a well-prioritized, efficient manner allows you to establish a scene layout with a very real feeling sense of space  quickly and effectively.

[finticemo]

FAQ

This post is intended to address in advance a few things that might come up. It will be linked in the header of all 3 of my tumblrs.

When reposting art on another site, what name should I use to identify you?

'finticemo'. I'm fine with all my art, NSFW or not, finished or not, being associated with this name. The separate tumblrs are basically just in acknowledgement that different people want to see different stuff.

That's it for now.

[finticemo]

[finticemo]

A brief tutorial on `find` and brace-substitution

When I'm scanning stuff, I divide stuff into categories. cause I draw a lot, and prefer to scan as much as possible rather than be ultra picky about what I scan; I have a lot of scans, and it would be too difficult to organize them if I just dumped them all in one directory.

So I end up with a top level directory like this:

2015/scanned/jan05_2015

and under that directory, I have subdirectories such as

anima anima/pose anima/portrait anima/anatomy anima/animals design design/icon design/design design/typography design/sequence design/clothing hard_surf scenery scenery/landscape scenery/plants scenery/interior

This structure doesn't change much month to month. So it would be convenient to just copy the directory structure straight over for each new month, right?

I wrote a function to do that, and put it in my .zshrc. Here it is:

mirror_dirstructure() { # mirror dir structure to current directory # -- or $2 if given. PREFIX="$1" PREFIX="${PREFIX%/}/" DEST= if [ -n "$2" ]; then DEST="$2" DEST="${DEST%/}" fi find "$PREFIX"* -type d | while read DIR; do DIRNAME="${DIR#$PREFIX}"; mkdir -p "${DEST}${DIRNAME}"; echo "$DIRNAME"; done }

which can be used like so:

mirror_dirstructure /home/me/x/2014/scanned/dec04_2014 /home/me/x/2015/scanned/jan05_2015

to mirror directory structure from /home/me/x/2014/scanned/dec04_2014 to /home/me/x/2015/scanned/jan05_2015

It's true that you could just copy all the contents of the directory.. but then you would have to go in and tediously delete all the old files. This function simply does the whole job in one go, without any unnecessary copying.

Here's a breakdown. Step 1, sanitize arguments.

PREFIX="$1" PREFIX="${PREFIX%/}/" DEST= if [ -n "$2" ]; then DEST="$2" DEST="${DEST%/}" fi

We set the variable PREFIX to the value of the first commandline argument, $1. Note that we are "double-quoting" everything whenever we do an expansion. This is an important safety measure, as values containing spaces or other special characters can cause problems otherwise. See this article for a comprehensive explanation of how to correctly handle filenames in shell scripts.

We might get an argument like "foo/bar", or an argument like "foo/bar/". We need a standard form, so first we use the 'remove suffix' expansion code -- ${VARIABLE%SUFFIX}, to remove a trailing / if it exists (and do nothing otherwise), then append a / to that -- so, we should always end up with exactly one / at the end.

According to this rule, the example parameter /home/me/x/2014/scanned/dec04_2014 would become /home/me/x/2014/scanned/dec04_2014/.

We set the variable DEST to an empty string. The result of this is that "${DEST}${DIRNAME}" will expand to exactly the same value as just "${DIRNAME}". This is what allows us to omit the second parameter to mirror_dirstructure.

We check (if [ -n "$2" ];) whether the second argument is non-empty (ie. is a string containing 1 or more characters). It's especially important to quote the expansion, here, as if $2 is empty, expanding it unquoted is equivalent to expanding nothing at all, much as I explained with DEST above. -n "" provides one argument to -n, while -n (what we would get if we expanded $2 without quoting) provides no arguments to -n and will produce an error.

If the second argument -is- not empty, we do the same procedure as before to strip a trailing slash if it exists, then add a single slash to the end.

...

find "$PREFIX"* -type d | while read DIR; do DIRNAME="${DIR#$PREFIX}"; mkdir -p "${DEST}${DIRNAME}"; echo "$DIRNAME"; done }

we ask find to find all directories (-type d) inside $PREFIX, looking at all the files/directories in $PREFIX. The reason we use "$PREFIX"* is because we do not want find to return $PREFIX itself as part of the list of results -- obviously $PREFIX is itself a directory.

Note that "$PREFIX" would not do what we want here -- it would produce the value of PREFIX followed by a literal "", rather than performing wildcard-expansion to get a list of all items inside $PREFIX. The reason I insist on quoting $PREFIX, here, is again because if it contains spaces or other special characters, the result may not be what was desired -- if it had spaces, then two arguments might be given, as in find foo bar/ when PREFIX equals "foo bar/".. that would attempt to look in foo and in bar, neither of which would actually exist, most likely.

We pipe the output of find into a while loop. This while loop will continue until the command read DIR returns a status of nonzero, which will occur when it reaches the end of find's output, in this case.

This while loop reads one line at a time from find's output. Doing things this way, rather than for DIR in $(find "$PREFIX"* -type d);, makes things safer, again, particularly if filenames happen to contain spaces. This article further explains this choice and why you would make it.

in general, read returns a nonzero status code whenever it reaches the end of the file it is reading, whether that file is a real file , or just a pipe, as it is here.

Inside the loop: we chop off $PREFIX from the $DIR we just read. This is the main reason for going to the trouble of ensuring $PREFIX ends with a /. We do this using the # brace-expansion code -- 'remove prefix'. This turns '/home/me/x/2014/scanned/dec04_2014/anima' into just 'anima'.

One note on something potentially confusing here: With extended brace expansion, as in "${DIR#$PREFIX}" , you specify a variable name on the left side, without a $ to indicate an expansion. But in the right side, you will need to use $ expansion as usual, if you want to expand variables. This is because extended brace expansion is an extension of the basic ${variable} brace-expansion, which does not repeat the $ either. Extended brace expansion is saying 'expand this variable, and do X to the expanded value' -- it contains an expansion -- ${DIR} --, an operator -- # --, and a value, $PREFIX

The rest is pretty simple. We stick DESTDIR and DIRNAME (The value of $DIR with $PREFIX removed) together and ask mkdir to make that directory and any intermediate directories needed -- for example, mkdir -p "foo/bar", if foo doesn't exist, creates foo and then creates foo/bar. This behaviour is requested using the -p option, mkdir will print an error in such cases otherwise.

And finally we use echo to report to the user that we have processed this directory.

[finticemo]

tmsq, a caching wrapper for `tmsu files`

I wrote this today, finally.

It's a wrapper for 'tmsu files' which remembers your query results for N minutes (default 30), and returns them quickly when you ask for them the second,..Nth time.

If you're not aware what TMSU is, well, per the wiki:

TMSU is an application that allows you to organise your files by associating them with tags. It provides a tool for managing these tags and a virtual file system to allow tag based access to your files.

I use it to organize my art and references.

Example usage is just like tmsu files:

tmsq banana not apple

to return files that are tagged banana and not tagged apple.

tmsq supports all tmsu files options as well as the overall tmsu options TMSU_DB, -D/--database, -v/--verbose, and a few others -- --clean-cache, --list-cached and -o/--cache-timeout

Mostly useful for queries that take a while to execute (eg. complex queries, or queries with large numbers of results) and do not need to be up-to-the-second accurate. If you have a small TMSU database, you probably won't gain much from this. I wrote it because my database is large enough that some queries take 20 - 149 seconds, whereas returning the cached results takes 0.1-0.3 seconds.

Known issues:

Commandline help doesn't indicate the remaining arguments (ones that will be passed to 'tmsu files')

bad arguments (eg --some-nonsense-option) get treated as part of the 'tmsu files' arguments. Not really avoidable, just something to be aware of. In this case tmsu files should return no files and you just get an empty cache entry.

No Zsh completion. Would be a fairly simple modification of the 'tmsu files' completion code included as part of the TMSU distribution, once I understand how that works.

It may be worthwhile to take over the -c/--count option to tmsu files -- certainly significantly faster than treating --count and non --count as different queries. Maybe the same holds true for -0.

For now, it's hosted on bpaste. If anyone aside from me finds it useful, I'll put it up on gitorious.

Enjoy.

[finticemo]

Tastes

Tastes do not answer to logic or sense. It's nice to have tastes that make sense, but it does not make your tastes 'better'. Tastes cannot be compared like that. Your taste is not better or worse than other peoples, it is just your taste. There are many like it, this one seems special only because it is yours. Give it low priority and others tastes identical low priority. Tastes are ultimately of low importance, they will steadily adapt themselves to your situation. What matters is how you think and how you act.

Tastes are like feelings. They can be used as tools (for example, motivating yourself with the promise of chocolate once you finish this task.) but have no informational value, so if they are in control there is a problem. Your comfort zone, for example, is a conglomeration of tastes. It's a lot easier to push your comfort zone if you really understand that when you get that feeling 'I don't like this', that's normal and just reflects that you don't have a taste for this yet, rather than reflecting some objective state of reality. Tastes, like feelings, are transitory.

[pintafema]

G’MIC color flatting tutorial [1]

[1] Color not included ;)

The G’MIC colorize[comics] filter, found in the ‘Black & White’ section of the GIMP GMIC plugin, is pretty easy to operate. There are only a few things to note:

Your ‘markings’ layer should be the one selected when you invoke GMIC

The layer below it should be your lineart.

Select ‘Active and Below’ as the input layers.

Applying the filter will output 3 layers : the generated fills, the markings layer, and the lineart. You probably then want to hide the markings, and move the lineart above the fills layer.

This is not restricted to grayscale flatting or a limited number of colors. See This post by Timothee Giet, for another demo of GMIC Colorize Comics.

[finticemo]

Reblogging tutorial post.

[finticemo]

Simple scrolling background with GIMP-GAP

This tutorial explains how to pixel-perfectly scroll an image that is larger than the view area. It is a technique that can later be generalized to parallax scrolling.

The result looks like this (heavily color reduced to reduce size):

Ingredients:

one static image to be scrolled (640x240)

one 'blank' animation (320x240, 160 frames)

Note that the image doesn't have to be static, nor does the animation need to be blank, but we ignore these factors for now for simplicity's sake.

How do you create a blank animation?

This is a simple three-step process:

first, create an empty image of the correct size (320x240).

Next, save it with a filename like 'myanim_001.xcf'. The 001 indicates it is the first frame in an animation.

Use the menu item Video->Frames Duplicate to duplicate this frame. We want 160 total frames, and 1 frame already exists, so we set N to 159.

We now have a blank 160-frame animation

How should you make your image-to-be-scrolled?

It can be any kind of content that you could put in a normal GIMP layer. In this case we will use a completely opaque background so that the black we started with does not show through.

This is the background image I will be using:

It's very simple, created by throwing some patterns together in gimp and applying GMIC's 'Segmentation' filter to block-ify the color areas.

Compare it with the shape of the the blank image we are using:

It is exactly twice as wide.

** Calculating keyframe positions **

For this animation, we will scroll the image smoothly to the right.

Position keyframe coordinates in GIMP-GAP are relative to the animation which you are adding to. so, (0,0) would place the top-left corner of the background image at the top-left corner of the animation.

Note that coordinates are zero-based. 0,0 is the top left of the canvas, 319,239 is the bottom right. Keeping this in mind may save you some confusion on more complex animations.

Considering these factors, at the end of the animation, we want the position of the background to be (-320,0) (placing the leftmost 320 pixels of the layer off-canvas, and having the rightmost 320 pixels visible.)

This means the background travels exactly 320 pixels in 160 frames.. exactly 2 pixels per frame. We could choose other speeds, but we must choose both the movement speed and the number of frames carefully, to ensure that we can truly get pixel-perfect scrolling. When you divide the number of frames by the distance travelled, it must be a whole number to achieve pixel-perfect scrolling.

Preparing

Before we actually scroll the background, there is one important condition that must be met:

Make sure that both the blank animation and the background image are open in GIMP.

Inserting and scrolling the background

We insert and scroll the background with a single, versatile command: "Move Path". Like all other GIMP-GAP commands, this can be found under the 'Video' menu.

This is a powerful and somewhat complex GUI, but for now we can ignore most of it.

First, we need to select the source image using the selector near the top left.

The Move Path dialog always starts with a single point, set to 0,0. This happens to be what we decided was our first keyframe, so we leave it as-is.

We need to add another point, using the 'add point' button, and set the 'x' input box to -320 (this is the most reliable way of choosing positions that are off-canvas.).

We now have the correct keyframes. Notice how Keyframe is grayed out. This is because the first point is always mapped to the first frame in the frame range, and the last point is always mapped to the last frame in the frame range.

Note the From Frame,To Frame pair on the right. This should be set to 1, 160 as shown.

We can now preview the output (this is optional, but usually helps avoid unnecessary render time):

Click 'Anim Preview'. Some work will be done, a new image will be created, and the standard Filters->Animation->Playback command is automatically invoked on it.

Hit Play to play the preview. You can alter the playback rate. play or pause the animation, and step through the frames. This is good when you are experimenting with timing.

Close the Animation Playback window when you are satisfied.

A few other items in the dialog are circled in red, I will get back to them later.

Hit OK to actually insert the background image in your animation. Some time will be spent rendering.

When rendering finishes, your previously blank animation will contain the scrolling BG.

Converting to GIF

GIMP-GAP also supports rendering to normal video formats like MP4, but we want a GIF.

We can create a GIF with the help of the Video->Frames to Image command. This is a reference to the fact that the builtin GIMP animation filter contains all the frames as consecutive layers in a single image.

We can safely ignore most of this dialog, we only care about the From Frame and To Frame settings, which should be set to 1 and 160 respectively; then we can click OK. GIMP-GAP will create a new image.

In this new image, we just need to do the normal things to prepare a GIF now:

Convert to Indexed (Image->Mode->Indexed, click Convert)

Filters->Animation->Optimize for GIF (this probably won't save much on this particular animation, but it's a good habit to get into)

Optimize for GIF created another new image, which we will Export as a GIF.

'As animation' is the only important thing here; it should be checked, then you can hit Export.

Here's the result (again, heavily color reduced to reduce size)

Extra Info

(EDIT: removed image, it was incorrect)

There are a few things here I didn't explain earlier:

Next/Prev point : use these to navigate through waypoints as needed.

The color panel on the left: Waypoints are shown in this color, you can click on it to change it in case it blends in too much with your image.

Layerstack: This effects where in the layerstack the item is inserted. 0 is the top of the stack (above everything else), 1 is one below the top of the stack, ... -1 is at the bottom of the stack.

Another thing, that I didn't circle, is the 'handle'. This specifies exactly what point in the inserted image the X,Y coordinates point to. For backgrounds, Left Top is good, but for other types of object, Center or other settings may be more useful.

In this animation, we just use the default FPS, 24. If you want a different FPS, you can use the Framerate field in Video->VCR Navigator to set it.

** Credit **

cels on Pixelation forums: Inspired me to write this up properly

retext: MarkDown editing with live preview.

Shutter: Screenshot capturing and annotating.

GIMP, GIMP-GAP: Tutorial subject