LightningIsMyName's Website

Post-GSoC work, End(?) of University

2012-02-10T23:29:00.000+02:00

I have done the seamless cloning project for GIMP and finished it in August. So, you may ask, why on earth is it not integrated yet? The answer is short and simple - last university semester combined with real life. But, I'm not here to bring excuses, I'm here to bring results:

On Thursday I had my last university exam (Computational Complexity). Unless I fail, and I hope I don't, I finished university!
In the last two weeks of university, I had more and more free time so I began working again on my GSoC project. The current things that are waiting to happen are:

Fix the triangulation refinement implementation. For those who are not familiar with the algorithm behind the scene, the algorithm itself is based on interpolation of image differences in a triangular mesh. Therfor, it is a critical part.
The algorithm currently would get stuck in an infinite loop of refining the triangulation, even though it was gauranteed to stop (meaning an implementation bug). I think I just fixed it now (now as in 5 minutes ago), more on this below.
Make the algorithm iterate over tiles inside of allocating a big chunk of memory, and thus limiting the maximal image size for the algorithm.
Fix memory leaks (there are several known leaks, and hopefully none unknown).
Improve a small glitch on the borders of the image.
Optimize the speed!
Get it reviewed, and merge back to master.

Being free of university, and free from other work (I have a day work on which I don't work "after-hours"), I'm now free from chores on evenings (if I get home at sane hours) and weekends. For the first time in the last 3.5 years, I really have free time with nothing on my mind. So don't worry, I'll get into GIMP :D

Now, before I get into details on my GSoC bug, a short "what's going on?".

Last time I left the geometry library, I was completly stuck with no idea what was the bug.
When I got to it again, I decided to re-write it in a language which is more type-safe (no pointer bugs), with less memory issues (garbage collection), and much easier to debug (no offense, but gdb isn't always ideal). Eventually I chose C# (and not Java, my favorite language) in order to learn a bit.
I have been spending my free time between the exams, in the last two weekends, to re-write the library. The re-write was something like "look at the code and write it in a different language". Almost no structural changes or anything, so that I'll keep synced with the source.
And then I found the bug...

Now for the bug, which made me like C much less than I did before:

// Relevant type declarations:
typedef enum
{
  INCIRCLE_ON,
  INCIRCLE_INSIDE,
  INCIRCLE_OUTSIDE
} P2tRInCircle;

// Types from GLib
typedef int  gint;
typedef gint gboolean;

// The function I called
P2tRInCircle p2tr_math_incircle (P2tRPoint* a,
                                 P2tRPoint* b,
                                 P2tRPoint* c,
                                 P2tRPoint* d);

// Somewhere in the code, in the function that I knew that
// was deeply related to the problem:
gboolean inside = p2tr_math_incircle (p, a, q, b);

if (inside)
  {
    ...
  }

I don't even feel like explaining this. It is so trivial (and if not, go learn C!) Other than feeling ~~stupid~~ silly for falling on such a bug for days of debugging, I don't have anything else I can say... So, with all the dislike of some people to high level languages, I like type safety. It saved my here simply since this code, when converted directly to C#, didn't compile and produce an error instead!

So, Hurray for C#, Hurray for end of University (hopefully) at least untill second degree, and just some other random hapiness. And don't worry, I'm not gone yet :)

Edit: More silly bugs found. I'm starting to like re-writing stuff - way better than debugging...
Edit 2 (February 11th, 2012): The geometry library works, at least in C#. Now it's time to re-implement in C.

Quick Update - NGtk

2011-10-23T01:06:00.003+02:00

To those of you who have read my previous blog post regarding NGtk, here is a quick status update:

NGtk works. Tested the XLib and NCurses backends on several linux distributions, and tested the WinApi backend on many versions of windows. I have a calculator app working with keyboard and mouse support.
Keyboard focus is crappy, in all backends. Currently, I just tell all the widgets to listen to keyboard events. This is not something that is hard to fix - an hour or two.
In backends with custom drawings (XLib, NCurses), the widget state isn't considered when drawing (so the widget looks the same all the time (if it's visible)). Not a bug, but could use some fixing. Base code for fixing that is already there.
Clicking on disabled Widgets in the WinApi backend causes the mouse event to pass to the parent container (instead of being sent to /dev/null). Does anyone actually care about this? Can this do any harm? Anyway, the nice guys at Stackoverflow suggested a solution that should be easy to implement (but it's not top priority at the moment).
Removing widgets from their container isn't tested well enough. That's not a bug, but I simply can't gaurantee good behaviour

Also, here are some good things:

It works!
It doesn't crash
It doesn't leak memory (take that Gtk+!)
Valgrind is generally happy
Did I mention that it works? :P

I handed in NGtk to my proffessor, which means I'm now on my own with this project. Expect release 1.0 soon (my submission was titled 0.99). For those who want to take a look at the API usage already, you can take a look at the tester program: main.c (forgive me for the ugly macro in line 204, there is already a way around it in the code on my computer).

It is useable already (you can get the link to the project homepage from the main.c link), but I deeply recommend waiting for me to solve the above technical issues.

By the way, I did 40 km of bicycling in the city last friday (October 14th) in the Sovev Tel-Aviv event. It's the first time I participate, and I really enjoyed. Riding the bicycle on the busiest highways in the country and then along the sea shore together with other hundreds of people, is a great experience. So, if you can participate next year, I highly recommend that you do so ;)

Teaser: Project NGtk - Native Gui ToolKit

2011-10-12T21:48:00.000+02:00

Recently, I wasn't exactly active in GIMP and other projects. The main reason for that is an open-source university project I am doing as part of my studies, in the course Advanced Topics in Operating Systems. I believe pictures can demonstrate better than words, so take a look:

Click on the image to view it in fullsize

Project NGtk is an extremly light-weight library for creating GUI's on different platforms. It includes the following features/concepts:

Has support for the following widgets and events:

Button (stable)
Labels (stable)
Text-Entries (stable on 2 of 3 platforms)
Windows (stable)
Mouse up/down/click events
Keyboard key type events, with translation from key code to ascii

Works on the following platforms:

Windows - Uses native Windows widgets via the windows API.
For this backend, the only dependancy is the windows libraries which already ship with Windows.
Unix/Linux Terminal - Any terminal which NCurses works on (which should be most modern terminals). This means you can also use this via SSH without X11-forwarding! Unlike many curses applications, NGtk includes full support for mouse cursor in the terminal.
For this backend, the only dependancy is NCurses, which is shipped with most (if not all) modern linux distributions. NCurses supports a large variety of terminals.
Xlib - Any operating system which has an Xlib (X11) client library. This means graphical Linux/Unix work environments.
The only dependancy for this backend is an Xlib implementation, which is shipped with all modern graphical Linux/Unix environments.
Gtk+ wrapper - Support planned for near future. This will practically be a simple API wrapper to give API consistent with other NGtk backends.

30 KB for the core library + 30 KB for each "adapter" (backend library). Just for comparision, Gtk+-3 is approximatly 4 MB (130 times bigger), not including it's dependancies.
Written in C
Object-Oriented structure - NGtk uses a very small C object system that was written as part of this project to make it easy to rogram, and without requiring C++. The object system is easy to learn and well documented.
Display "Resolution" Independant - Forget the term pixel, as it doesn't exist in NGtk. Since NGtk is meant for a wide amount of platforms, such as the terminal (where a the smallest unit, a "pixel", can actually be a whole letter), NGtk will handle sizing of widgets itself. You can specify logic layouts, but no need to actually specify a size for widgets. There is a built-in interface for accepting custom made layouts (anything from grids, relative sizings, etc.), and writing new layouts is easy.

As you can see, NGtk doesn't have any real dependancy - the only dependancy it has is the existance of the graphical system that you wish to use. It is also not a replacement for Gtk+/Qt/etc. - it's targetted only at people who want very light-weight GUIs (both in features and in actual library disk size), and want to acheive maximal support. The NGtk goal is to achieve a state where every platform with a compiler will have an NGtk backend that will work on it without requiring any library which isn't already on the platform.

The first stable release of NGtk will happen this week when I hand in the project to my university. You can already find the project source by googling it, but I do recommend waiting for the official stable release.

Regarding my GSoC project: no I haven't forgotten. It won't make it in time for 2.8, but I will work on it as soon as I can hand in NGtk to my proffessor. Sorry to disappoint the people who wanted to see it soon, but it just won't happen...

Saving Vertical space in GNOME 3 (Especially for Firefox)

2011-09-24T21:19:00.000+03:00

I have been using GNOME 3 for more than a week now. I really like it, and after tweaking my desktop back to show the files and launchers (like in GNOME 2) I really felt at home.

However, not everything is great with GNOME 3. One of the most irritating features of it, is the gigantic titlebar of windows. I actually like gigantic titlebars, but not when I need to maximize my working area. The web is full of people complaining "Why Firefox on Linux can't be space efficient as it is on Windows 7?" This is even more critical when in the fallback mode, you have two very thick panels that also take additional vertical space (I switch between fallback and regular all the time because of some hardware limitations).

Comparision between Firefox titlebar on Windows 7 and GNOME 3 (fullsize)

As you can see, the Windows 7 setup takes much less space, by combining the titlebar with the tab area. Very neat!

Anyway, I'm here to say that you can make Firefox on Linux thinner. I'm not talking about fullscreen mode in firefox - since I do like seeing my tabs and toolbars (Which firefox hides in fulscreen mode).

In Linux, windows are displayed and managed using a special program called a Window Manager. We are going to request the window manager to display Firefox in full-screen. This is different from firefox's built-in full-screen mode! In the full-screen mode created by the window manager, Firefox will continue to show it's tabs and toolbars like before, but it's titlebar will be gone and it will fill the area that was used by the gnome panels!

Open the System Settings dialog (in fallback mode, it's in Applications → System Tools) and Choose Keyboard. (Screenshot)
Switch to the Shortcuts tab and choose Windows from the options on the side. (Screenshot)
Find the Toggle fullscreen mode option, and assign a new keyboard shortcut which is easy to remember (I used Ctrl+Alt+F). To assign a new shortcut, click on the area which displays the shortcut (it displays Disabled if no shortcut is set) and type the desired key combination.

Now, whenever you open Firefox (or any other program that needs more vertical space, without sacrificing any toolbars that disappear in the built-in fullscreen mode of that program) simply type the shortcut from above to go fullscreen! Type again to get out of the full-screen mode.
You are going to miss the close/un-maximize/minimize buttons in fullscreen mode. However, you can probably live without them (or if you like keyboard shortcuts, configure some for these also!) when working in fullscreen.

That's it, I hope it helps those of you who need to use more height of their screen and don't like the built-in fullscreen modes (if any) of their programs. If anyone knows any better way (especially for Firefox on GNOME 3), please leave a comment :)

Video demo of my GSoC project

2011-09-05T22:51:00.001+03:00

[If you are reading this from RSS, you may not be able to see the video. Click here to see it]

[GSoC-2011] Final Results and How to Try

2011-08-29T01:06:00.000+03:00

I am very glad to announce that I now officially passed the Google-Summer-of-Code 2011 :) The email from Google arrived in the last few days, and the official Google announcements on the GSoC results (of all projects) are supposed to be published tomorrow.

S/He is eyeing you :)
Sources: background, paste

Now, it’s time to publish the instructions on how to get and try it for the people who want to test it. There are some known bugs, and probably some unknown bugs, so be warned.

Compilation and Set-Up Instructions

You should know how to build of GIMP and GEGL from Git. A partially outdated guide is available here, and some things are explained in more depth here.
Instead of building the GEGL master (main) branch, switch to the soc-2011-seamless-clone branch. You can do this by running git checkout soc-2011-seamless-clone. Compile it with the regular flags – nothing special is needed.
After building the updated version of GEGL, it’s time to build the updated version of GIMP. Switch to the soc-2011-seamless-clone2 branch, and build it.
Before running GIMP, you must set the environment variable p2t_refine_steps to some number defining the maximal amount of points to be used in the mesh (in plain English, more should theoretically produce better result). I know this is annoying, I will get rid of it as soon as I finish debugging a certain code part. The typical number I use is 500 for pastes of around 200x200 pixels, and you should probably increase it if you wish to work on large pastes.If you are using the bash terminal, do export p2t_refine_steps=500 (and change the number as you wish)
Run GIMP.

Usage Instructions

Basically, you can just try copying a part, selecting the Seamless Clone tool (Shift+L) and clicking anywhere on the image to start the tool’s interaction. Click Enter to apply the final result. If this doesn’t work (and/or crash), then the instructions below are for you.

Run Gimp :)
Open the image that you wish to use as the background, and open the image you wish to paste into the background.Copy the part you want to paste. Note that opacity of that part will be treated as if it was binary – parts under 50% opacity will be removed, parts of more than 50% opacity will be completely opaque. The shape can be any shape, as long as it follows the following rules:

It must not have holes (Temporary limitation)
It must be continuous, i.e. composed of only one part (Temporary(?) limitation)
It must not have any long thin areas (Temporary(!) limitation).
This means that if you have any area which is 1 pixel wide and is 3 pixels long or more (i.e. a thin spike), it will crash. Solution for this was already devised, I just need to code it.Select the Seamless-Clone Tool (Either by clicking the second tool on the toolbox that has the same icon as the move tool, or by doing Shift+L).

Click anywhere on the canvas while the background layer is active. The paste will be centered on the cursor, and so the cursor should be in a place where the entire paste is inside the background boundaries (both inside the rectangle defining the layer, and inside an area where all the background below it is opaque). This limitation will be enforced by the User Interface later.
Move the paste by clicking on it, dragging and releasing. If you move it slow enough (which actually shouldn’t be so slow), you’ll see the preview updating while you are moving.
Click Enter to Apply the effect.

Known Bugs

All the above mentioned crashes and bugs :)
Due to not yet complete memory management, the tool leaks memory from it’s preprocessing.
Converting to tile-based processing is NOT 100% done, so it may crash on large pastes. Don’t ask me how large since I didn’t try anything more than 300x300 on my machine.

Other TODO’s

Integrate the tool with the help system
Test better the interaction when the the active image/display/drawable are switched during the interaction of the tool.
Get a decent tool icon. Anyone with ideas for the visual metaphor to be used by a seamless paste tool, is more than welcome to leave them here as comments! I do design icons, but I don’t have an idea for this one.

GSoC 2011 - (Almost) Final results and thanks!

2011-08-15T14:50:00.009+03:00

The end of Google Summer of Code 2011 is near, and I have failed to post enough updates on my blog. But that does not mean one bit that I failed to make progress. I'm proud to present you with my results:

Result, using my GIMP tool :D

The image to paste (source)

The image to paste into (source)
Licensed under Creative Commons Attribution-Share Alike 3.0 Unported

My tool allows you to move the paste on the image and see it update according to it's environment, so that it will paste seamlessly. It's not real-time yet, since I recompute some values that should be cached everytime, but most work to enable caching is done, and I hope to reach that before the final deadline. (Even if it won't be before the deadline, I will do it even after GSoC ends).

This is also the time to thanks all the people who made this possible:

The authors of the Coordinates for Seamless Cloning article, who developed this algorithm.
Prof. Daniel Cohen-Or, the professor who taught me computer graphics at the university, and helped me understanding the article (he is also one of the article authors).
My GSoC mentor, Michael Natterer (aka mitch), who agreed to mentor me and assisted me when I was stuck.
Mason Green, the original author of the poly2tri library, which was heavily used in the project for computing interpolation meshes. I would have never reached the project deadline without his amazing library.
Prof. Jonathan Richard Shewchuk, who developed some of the geometrical algorithms that were used in this project.
Finally, special thanks to all the great guys on the GIMP and GEGL irc who helped a lot - mitch, Bat`O, pippin, Alexia_Death, Mikachu, and more.

Open Devhelp books installed in unusual locations

2011-08-07T03:37:00.005+03:00

If you are a GNOME developer, there are high chances you encountered this problem - you install your beta versions to a seperate prefix (something like /opt/my-beta instead of the regular /usr), and then when you come to browse their documentation in Devhelp, it fails to find them. Some will be tempted to sudo, and then symlink the documentation to /usr/share/gtk-doc. Personally, I'm not a fan of sudo-ing and messing around...

Today I had enough of this, and decided I'm going to solve this. A quick search in the Devhelp source code found the code that searches for books. The book_manager_add_books_in_data_dir () function searches SOME_PREFIX/gtk-doc/html for Devhelp books, and it's called from dh_book_manager_populate () with the directories returned by g_get_user_data_dir () and by g_get_system_data_dirs ().

Thanks to some help from Mikachu (from #gimp irc), which matched the much longer description on the freedesktop basedir-specs, I found out that appending a directory to the environment variable $XDG_DATA_DIRS is enough to make Devhelp search for documentation there.

Sweet! That was much easier than I thought it would be :D

So to summarize, this is what you do:

Compile your program, while setting the installation prefix to some prefix $PREFIX
Build and install it (make and make install)
Find your installed gtk-doc documentation. Usually it is located on $PREFIX/share/gtk-doc/html/YOUR_PROGRAM. Make sure that directory contains a file with the suffix of .devhelp.
Set the $XDG_DATA_DIRS environment variables, and prepend (don't append!) that directory (usually $PREFIX/share) to that variable. In bash syntax, you should type
export XDG_DATA_DIRS=$PREFIX/share/:$XDG_DATA_DIRS

Why prepend and not append? Well, apparently Devhelp doesn't seem to like having two books with the same title, so it takes the first one it finds... Since it follows the directories in that environment variables by their order, it means that we should add our directory to the begining of the search path.

Note that this method has 2 cons:

You can't view previous versions of the documentation, since as I said Devhelp takes only the first version it finds
You must launch Devhelp with the above environment variable set. So either lunch it from your build console, or create a script to modify the variable and then lunch Devhelp. Note that IDEs that launch Devhelp (like anjuta, and gedit with plugins) must have the variable set for themselves (by launching them with the variable set already).

So, it's not perfect. But way better that symlinking stuff into the /usr/share/gtk-doc directory. This also shows why open source is so good - "If you don't like it, fix it!". Or as I prefer to say "If you don't like it, hack it" :D

QuickBox–A quick point-in-triangle test, and an example of how algorithm descriptions matter!

2011-08-01T06:33:00.001+03:00

In this blog post I'm going to post something which is rather unrelated to my usual topics. I'm going to talk about how can minor changes in concept when coding, can have dramatic impact on your code performance. I also introduce a technique that I “developed myself” while coding the problem. When I say “developed myself”, I mean that I actually took time to code all the ways people describe the problem’s solution – although all seem very similar, the performance difference is huge.

While working on my GSoC project, I needed a fast predicate to check if a point is inside a polygon (specifically, a triangle). The test doesn't have to be accurate, but it must be sound in the sense that when it states a point is outside, then it must be outside. To do so, I decided to use bounding box testing - see if the point is in the bounding box of the polygon. Computing the bounding box of a group of points should be easy - just keep track of minimal and maximal X and Y and you should be done. So, how much can you screw it up?

Well, apparently, you can screw pretty damn hard. By coding without thinking, you can make this twice as inefficient without even noticing! Thinking before you code, to try and merge cases, can apparently be very productive. My solution will be referred to through this post as the QuickBox solution.

Explanation

The QuickBox test uses an improved version of a common idea. The usual checks see if in a point, one of it's components is larger/smaller than the matching component in all of the triangle's points. The implementation here takes this one step further, under the assumption we are willing to say that a triangle made of 3 collinear points contains no point at all (not even it's own points). This is fair for most triangulation libraries, that simply don't accept such triangles.

The idea is like this: If all the points of the triangle have the same boolean result for testing order (using <=) against a component of the point (for all i, Pt[i].x <= P.x is the same) then the following cases are possible:

All have the same value of the component. But then all the points of the triangle are collinear so it's practically empty!
All triangles points have the component larger than the tested point. So the point is outside!

All triangles points have the component smaller than the tested point. So the point is outside!

Note that principle explained above is also applicable for polygons with more than 3 vertices.

Implementation Analysis

Let the points of the triangle be A, B and C. Let P be the point we are testing.

Naïve implementation

This is what people would usually do if they translate directly the description “See if all polygon points are on one side of the input point (check that for each side)”

Compute:

((Ax <= Px) && (Bx <= Px) && (Cx <= Px)) ||
((Ax >= Px) && (Bx >= Px) && (Cx >= Px)) ||
((Ay <= Py) && (By <= Py) && (Cy <= Py)) ||
((Ay >= Py) && (By >= Py) && (Cy >= Py))

Total Cost: 12 double boolean operations, 11 binary boolean operations

Border implementation

This is what people would usually do if they translate directly the description “Find the the border on each side of the box, see if the point is beyond it”

           ABx           ACx                       BCx
xMin := (Ax <= Bx) ? ((Ax <= Cx) ? Ax : Cx)) : ((Bx <= Cx) ? Bx : Cx))
yMin := (Ay <= By) ? ((Ay <= Cy) ? Ay : Cy)) : ((By <= Cy) ? By : Cy))
           ABy           ACy                       BCy

// OPTION 1 - Requires computing all of ABx, ACx, BCx, ABy, ACy, BCy
xMax := (! ABx) ? ((! ACx) ? Ax : Cx)) : ((! BCx) ? Bx : Cx))
yMax := (! ABy) ? ((! ACy) ? Ay : Cy)) : ((! BCy) ? By : Cy))

// OPTION 2
xMax := (Ax >= Bx) ? ((Ax >= Cx) ? Ax : Cx)) : ((Bx >= Cx) ? Bx : Cx))
yMax := (Ay >= By) ? ((Ay >= Cy) ? Ay : Cy)) : ((By >= Cy) ? By : Cy))

Compute:    Px <= xMin || Px >= xMax || Py <= yMin || Py >= yMax

I'll assume that a trenary op is just one boolean operation and I will also ignore the need to save the values computed in the process such as ABx, etc. And even with that is still costs a lot!

Total Cost:

Option 1: 6+4 double boolean operations, 15 binary boolean operations. Actually, this method is rather inefficient, unless binary boolean operations are much much cheaper than double ones.
Option 2: 8+4 double boolean operations, 11 binary boolean operations. Exactly the same as the naïve method!

Note: separating the computation to one coordinate a time, can cut memory consumption by half.

QuickBox implementation, This is my method!

This is what people would usually do if they translate directly the description - “See if the point is on the same side of all the polygon-points”

xPBorder := Bx <= Px 
yPBorder := By <= Py


Compute: (((Ax <= Px) == xPBorder) && ((C->x <= Px) == xPBorder)) || 
         (((Ay <= Py) == yPBorder) && ((C->y <= Py) == yPBorder))

Total Cost: 6 double boolean operations (7 if we can’t save values (not 8! see below)), 7 binary boolean operations.

Note that you can expand this to polygons of much more vertices, using the trick above to avoid repeating computations, while keeping with only 1 variables which is neat :) Work on one coordinate (component each time) and keep an accumulating variable that after it’s initialized with the first comparison, you just compare to it! When done with that coordinate, if indeed you found no proof that it’s outside, pass on to the next coordinate and repeat.

Conclusions

It’s pretty easy to see that the QuickBox method beats the hell out of the competition! Less memory, less computations, and all because we checked “all points are on the same side” and not “all points are on one side” (and checked that for each side). So, when someone tells you how to implement an algorithm, try to rephrase his sentence. It can be critical!

Just some context about this post - I’m implementing a geometric algorithm that was given in 55 lines of pseudo code with ambiguous meanings. After passing 2500 lines of implementation (real C code), and after having to actually add many cases which were dealt with because the algorithm was phrased ambiguously enough with no hint to these cases, I started being very picky about how people describe their algorithms :P I spent 1.5 months of my GSoC on this, which is way more than I expected.

So do us all a favor – if you know how something works, describe it exactly and clearly, so other people can implement it correctly and efficiently. It’s preferable to have 100 lines of code that are readable in 15 minutes, instead of 15 lines of pseudo code which are quickly read but take a 100 minutes to understand! (But don’t over-do it! Bombarding with details will make people like me fall asleep when they read your article…)

[Final note: I don’t have any criticism at the original article author – he did explain it so that people from the field would understand (and eventually, even I understood so it shows he did his job very well). I just came from a different field since this is a side dependency of my project, and not it’s main part… This simply made me aware of how much phrasing of an algorithm can change it’s implementation for people who don’t think exactly like you]

Rescuing data from my dead laptop

2011-06-07T18:35:00.001+03:00

Unfortunatly, my laptop's sort of "died" yesterday. The usual procedure in such cases is to rescue your data, and then send the laptop to a service laboratory. However, rescuing the data was a bit harder than I expected it be... I'm using a dell laptop with windows 7 x64, and here are the steps I took:

Create a Windows 7 system repair disc (using my brother's laptop)
Boot the laptop from the repair disc
Run Startup Repair - didn't help
Run Windows Memory Diagnostic - which produced the lovely warning:
Hardware problems were detected. To identify and repair these problems, you will need to contact the computer manufacturer.
Complain about my crappy luck
Re-boot the laptop, and in the boot options menu choose the Diagnostics tool
After running the diagnostics, I got a more detailed error:
Error Code 0123
Msg: Error Code 2000-0123
Msg: Memory - integrity test failed
Googling that error shows that it will require reinstalling/replacing of my (RAM?) memory

So, that wasn't so bad. The problem is now, how to get the data out? Here is where things became tricky:

Boot the laptop from the repair disc
Connect a USB disk on key (8GB, FAT32 file-system)
Open the command prompt supplied in the repair disc and start copying files
After filling the Disc-On-Key each time, I emptied it on my brother's computer

And here it all goes wrong:

Got an error of a file which is too large for the given file system. I had a 4.35 Gb file of a virtual machine hard disk (VDI file). The maximal file size for FAT32 file system is 4Gb-1b :P
Format the Disc-On-Key, and choose an NTFS file system
Copy the big file and continue happily :)
Got another error - file is too big. Got this for a 9Gb file which represents the hard disk of another virtual-machine.

Now, we have a problem. The largest USB storage device I had is 8Gb, and in this minimal windows recovery environment I don't have any tool to split files!

After some thinking, I remembered that 7zip can create a split-zip, i.e. one zip that is split to several small chunks. Even better was the fact that 7zip has a command line portable version! So I quickly downloaded it, and went back to my dead laptop to try it. But, it didn't work... Apparently, in the repair disc, the files required to run 32 bit executables over 64 bit machines are simply not installed, and the command line version came only in 32 bit...

After scratching my head, I went back to browse my homework folder from the operating-systems folder. I remebered that we wrote a splifile utility in C, which uses only windows commands (for example, CreateFile instead of fopen). But, my version of Visual Studio is the Express edition, and it didn't have the 64 bit compiler...

So, I downloaded mingw64-w64 and went to compile my program. After some struggles with problems regarding unicode programs (solved here), and some other problems, I finally managed to get it compile. I went to back to my repair-disc boot, and it worked!

It took me several hours to solve all this, but I finally managed to do this. I don't have many complaints to microsoft or dell - the diagnostic tools were really easy to use and the repair disc booted without any problems. It's just too bad that the people at microsoft didn't think a split file utility is necessary when trying to rescue data... Overall, I began this procedure with great pesimisem, and I finished with a smile and no lost data :)

Regarding my GSoC - this will prevent me from working several days this week, since it's still the last week of the semester, so I still can't sit in front of my desktop computer. I'll make up for the lost time later somehow.

[GSoC-2011] Bi-Weekly update #1

2011-06-05T23:34:00.002+03:00

Hi!

After seeing enough student post of weekly updates, I decided that I should probably also give some progress report. I finished porting the poly2tri library to C! My C port can be found here.

Just compiled it today with gcc and not g++, and it feels great to see it working. And when I say to see, I mean that I created an SVG output tester so that you can see it in any modern browser :D
I still have some optimizations that can be done, including maybe some more documentation of the C api (especially for the constructor-destructor conversion from C++ to C), but it's usable enough for the GSoC as it is. Note that most API changes were simply from p2t::SomeClass::GetFoo to p2t_someclass_get_foo (where the object itself was added as a first parameter of the functions).
It was in "almost C" state on wednesday, but then memory leaks happened (solved with valgrind) and some stupid compilation errors...

At the weekend I went to a short vacation on the dead-sea (pictures soon!) and I had 4 people to discuss Chew's second algorithm (which I should implement next) with during the long ride to the hotel. So hopefully with their help it should be quick(er).

That's all for today :)

The end is near, and so is the beginning

2011-05-27T12:45:00.003+03:00

Pictures from Yehuda Poliker's Concert on the
Student-Day, and a picture of my GSoC kit. Cellphone
pictures, so low quality :P

There is a feeling of an end in the air. The end of university, another chapter in my life. Yesterday I took part in the Student Day party at our university - there were amazing concerts by fantastic artists, including Yehuda Poliker, Monica Sex, Hadag Nachash and more. The Student Day is a known symbol of the end of the year, which happens 2-3 weeks before the end of the semester. The fact that is practically my last year as a student (I will have one last course left for the next semester, but that doesn't really count) does start to get in, and I am gradually getting used to this.

This week was also the official beginning of the Google Summer of Code coding period! After getting my cool GSoC kit (see the picture) 2 days ago I really felt that I'm a part of this great project - many thanks to google for organizing this! Anyway, I almost finished porting poly2tri to C. Once this is done, I can start coding my project. The milestones for my project are:

Port poly2tri to C (from C++), a library for generating Constrained Delaunay triangulations for given polygons.
Implement Chew's Second Algorithm to create adaptive meshes from CDT's*
Implement code to create polygons from Black/White (1-bit) channels (The edges where the color differs should be described by polygons)*
Combine all these to create an adaptive mesh from a Black/White channel (which symbolizes a selection area)
Create a triangle mesh renderer with color interpolation between vertices (actually, Cairo may be able to do this!)*
Implement the Mean-Value-Coordinate cloning, using these above, as a GEGL operation*
Add some GUI and put it as a GIMP tool

Marked with * are the steps that would require the actual work, most other steps should hopefully be trivial. But again, hopes and reallity don't necessarily agree :) When I applied for this GSoC I knew there was code to do adaptive mesh generation from polygon outlines. It's only too bad that none of the code to do this is small and in a GPL compatiable license :(

I hope to finish everything untill step 4 (and parts of 5 if I'll be able to use Cairo) untill the midterm, but I can't really set the midterm goals yet since I haven't started to seriously code yet because there is still a university semester going on for the next week or two.

To all students out there, good luck in the exam period! And for the GSoC students, good luck with the projects! :D

I’m doing a Google Summer of Code!

2011-04-26T02:27:00.003+03:00

My application for a Google Summer of Code project for GIMP was accepted! =D
After being around the development team for a year or so (and hanging around the IRC even more), and after I couldn’t apply last year for technical reasons, this year I will get my chance.

Here is the initial description of the project, taken from my project page:

The project I intend to implement is something called Adaptive Cloning (aka Seamless cloning). Basically, the idea is that cloning parts from one image to another usually does not end well. This is because of different exposure/white-balance settings, or simply because of different lighting conditions.

The idea is to implement an algorithm which would allow to copy a part from one image, and paste it seamlessly into the other; the pasted area will be blended to fit the destination image locally. There are several techniques to do that, and the most known one is called poisson image cloning. The problem with most of these algorithms is that they are expensive (computation-wise) and are not suitable for interactive editing and previewing, unless you use hardware acceleration.

The suggested technique for my project is based on an article from Siggraph 2009 (includes demos and videos), which shows realtime performance (both on the GPU and the CPU*). The user would paste a some area from the clipboard and will then be able to "blend it in" according to it's environment.

I'm open for any suggestions regarding usability, ui integration, or anything which relates to the project. Feedback will be more than welcome!

* Note that I'm not sure for which sizes on the CPU it preforms on realtime, but it's still much more cheap computation-wise than most other techniques and a small lag of few seconds is something which should be acceptable for this sort of workflow.

GIMP has 5 projects for this GSoC – if all these projects succeed, GIMP will gain a major boost in it’s capabilities. This year’s projects are:

Adaptive Cloning (aka Seamless cloning)
- Student: Barak Itkin (IRC nick: LightningIsMyName)
- Mentor: Michael Natterer (IRC nick: mitch)
Replace GimpSizeEntry widget
- Student: Enrico Schröder (IRC nick: enrico(?))
- Mentor: Martin Nordholts (IRC nick: Enselic)
iWarp like tool for Gimp
- Student: Michael Muré (IRC nick: Bat`O) – the same guy who did the GSoC of the cage tool last year!
- Mentor: Alexia Death (IRC nick: Alexia_Death)
Porting GIMP plugins to GEGL operations
- Student: Robert Sasu (IRC nick: robert)
- Mentor: Mukund Sivaraman (IRC nick: muks)
OpenCL in GEGL
- Student: Victor Oliveira (IRC nick: victorm)
- Mentor: João S. O. Bueno (IRC nick: gwidion)

I would also like to congratulate Blender (formally, The Blender Foundation) for an astonishing amount of 17 GSoC projects! If there is any project who can do anything with 17 students, it’s Blender. Congrats also for Inkscape for 4 GSoC projects.

Good luck to my fellow GSoC students, especially the GIMP (and Blender) students. I hope I will finish my project – I already learned from Bat`O last year that it is feasible to code something like this ;)

The list of all accepted projects for all organizations for this year’s GSoC can be found here.

Small Help Wanted

I searched without success for a small GPL compatible library for generating quality triangular meshes (example) from a given outline (probably a quality constrained Delaunay triangulations / conforming Delaunay triangulation) - I need this for my project. I haven’t found any library that is both small and GPL compatible. If anyone knows any such library, please tell me - it will save me lots of work and guarantee less bugs in the final result.

Edit: It seems as if poly2tri may do the job of creating a CDT (Constrained Delaunay Triangulation), and on that I can apply Chew's second algorithm. This is not optimal, but it is feasible since creating the CDT was probably the hard pard. If anyone finds something better, I will still be glad to knkow!

Safe programming - Are universities doing it wrong?

2011-04-17T14:47:00.001+03:00

In the last 2 week I was unavailable because I had a “monstrous exercise” from university. Everyone indeed complained it was huge, but when other people saw the size of my code (2000 lines) they were shocked – this was because my code was about twice larger than the one of other people. It’s not that I suck at programming, and it’s not that I re-invented the wheel or anything like it. It was simply that my code was safe, where the code of most other people I saw wasn’t because we didn’t have to make it safe.

The assignment was to build servers and clients for a Nim game with several players (instead of just 2 like the original version) along with a build-in chat. What was supposed to be the point of the exercise was to make the server non-blocking, i.e. to use select() with only one thread. For example, this means that if we temporarily can’t read data from one client, we will still check if we can send him data or communicate with other clients. But let’s leave that technical part, since the thing that actually made the code complex was the other “minor” things.

Note: I have no criticism at all at the course staff of this specific course, It was simply an example of a university policy.

In general, when programming academic tasks, and especially when it’s in C, unless it is a course in security or some other special cases, you are allowed to assume the following assumptions:

Input from the user is valid (Less often than the rest of the assumptions, but still common)
We won’t run out of memory (in C, malloc() won’t fail)
Data received over the network is in the format we expected
No one will try to brake our system maliciously

Now, let’s analyze in how many places we can attack the server/client from our exercise:

Entering a wrong move to win the game

Example: Enter “A -5” instead of “A 5” to add 5 cubes to a stack instead of deducing (which is what that should happen)
Potential Result: Win the game by cheating

Sending large chat messages to attack client/server

Example: The protocol requests to send the size of the message to be read over the network. Most people used a short (16 bits) variable for that = meaning 65Kb message sizes are legal!
Potential results:

Buffer Overflows
Most people allocated a static buffer of size 1024 bytes (1Kb) for receiving messages since someone asked if 1024 is a valid assumption on input length. Reading 65Kb to a one Kb buffer will crash our program or lead to execution of arbitrary code.
Wasting resources
Allocating 65Kb for each client (to read chat message progressively until receiving them is done) is a lot of memory

Abuse the lack of timeouts on clients

Example: Connect with many clients, and do nothing after the connection was initialized.
Result: Can DDoS the system very easily, after finishing the maximal available number of connections, or waste all the resources if no such limit is set.

Send messages over the network in invalid format (can happen if client/server are broken)

Example: Send random binary junk
Result: see server crash or behave strangely

More…

Out of the above problems, I tried to take care off most of these problems, and I believe my partner and I took care of 90% of these cases. This is where we made our life harder – we didn’t have to handle any of these!

Now, obviously there were no requirements to handle these cases. This was done in order to allow students to focus on the subject of the task – non blocking network communication. And that is indeed something which should be done – otherwise you’d spend most of the time of the exercise (like me) on things which are barely relevant to the current subject.

So, after stating that we must take these assumptions, why am I writing this post? Because there is not even a single course in security and/or secure programming which is mandatory! Or at least this is how it is in my university (and I’m in a relatively respectable one). This means that a student can finish his entire degree without taking care of these problems even once! The implications of this can be devastating – if we code like we did in university, in the outside world, our programs will have more security holes in them that Swiss cheese!

Three weeks ago, I had to give a lecture (in a seminar) about common programming mistakes that make software unsecure. At first I thought most of the mistakes I was going to discuss were ridiculous, but then I saw them pile up in more and more “respectable” places – both in commercial companies (Apple, Microsoft, …) and open-source organizations. And like other programmers, I also do these even though I hate to admit it.

So, what can Universities do about it?

Changing the requirements of all exercises to be secure

Bad solution! The amount of work will make all students crash as if someone was DDoSing them :P

Mention the risk of each assumption inside each exercise description

Good!

Add mandatory courses/lessons in application security and/or safe programming

Better!

Instead of a one time experience during your studies (one mandatory course/lesson), have one task that should be safe in each course (where applicable)

Best!

And what can we do about it?

Try to show people we know were their code is dangerous, and increase their awareness.

If possible, try to attack their code and show them the actual risks! (because I heard enough people saying “The risk is only theoretical – nothing will happen”)

If you are a student, show this to the professors in the department of application security to make them tell the university to change it.

Some of them weren’t aware of the fact the state is so bad, and when they heard they started working to integrate the solutions mentioned above
But this is less likely to work…

Make our own code safe!

That’s all for today. Spread the awareness about security, and if you (as a student/programmer) found this post helpful, please let me know.

One last thing – I applied to GSoC (before the deadline), I’ll post my application later :)

Powerful experience

2011-04-08T15:40:00.001+03:00

Today at 6:40 am, near the Jaffa (יפו) clock tower, I began to walk. As I moved towards the Charles Clore park (גן צ’רלס קלור), people started to pour in from the near-by streets and slowly the stream of people grew to hundreds of people. The sky was low in the sky, hidden by large thin clouds, and rays of light blazed the sky through the clouds. When I finally reached the park, there were already thousands of people waiting.

At 7:00 am, I started moving towards the start line, along with many other people. Some ran bit, others stretched, and everyone were preparing. At 7:10 am, we were allowed to enter the gathering area before the start line. Gradually the area was filled, with 5,000 people, and it became pretty crowded. While we were waiting, some electronic music was played in gigantic speakers to get us all pimped up with energy. It drizzled a bit, and after 2 minutes it stopped.

At 7:25, a pistol shot into the air, signaling the beginning of the Tel-Aviv Marathon (מרתון תל-אביב) Urban Run Race - A quarter of a Marathon (10 Kilometers) race for people from all ages. Inside the huge “body” of participants, I started to move slowly towards the start line, and when I crossed it I began to run.

After several hundred meters, when the speakers were far behind us, there was a magical moment. It was silent, and the only noise that broke the silence was the soft pound of thousands of shows on the road. It was surprisingly silent, I thought that it would be much noisier.

After the first few kilometers, in which we went through a sleeping City, we saw people on the sides. Some of them simply stared, some have prepared in advance and stood with cameras and tripods, and some cheered the giant cloud of runners. Many of the cops who blocked the near-by streets were smiling at us, as if signaling us to go on. The city gradually came into life, shaking of the sleepiness that held it previously.

When we reached the middle of the race, we reached the first water stop. Many people holding bottles of waters waited for the runners to take & go, some were from the event staff, but some were certainly volunteers (they didn’t wear uniform). They all cheered and gave us motivation to continue. One thing that really made me smile, was one person who set-up a table on his own and gave water to the runners several hundreds of meters later. Every 2-3 kilometers there was a DJ/band playing music to keep us going.

Finally, when reaching the final 2 kilometers, we ran near the beach where we saw the deep blue ocean. At that spot, many people already gathered to cheer, photograph and play us music. It was a down-hill part, and everybody accelerated (knowingly or not) towards the finish line which was already in the horizon. On the right, we were passed by people participating in the Handcycle race that also took place as part of the event.

Hundred meters before the finish line, we already heard the gigantic speakers from the initial gathering area. Then came the urge to sprint forwards, to finish it as fast as you can, proving yourself you can do it.

It was the first time I participated in a race, and the feeling was fantastic. For me, like most other people, it was not a competition, but simply a chance to prove yourself that you can do it. So I proved myself I can do it, and I broke my own record and set it to 49 minutes and 20 seconds (previously, I did 9 kilometers in 51 minutes). More important than the record, was the participation, and prooving to myself I can do this and in a good time.

I think that one of the things that made this race an important experience for me, was the huge range of participants – ages 16 and up, were many of the people where in their 20’s-40’s (so I was relatively young – only 63 people including me where in the category of 16-19). There were people who ran in pairs or small groups, others ran in teams (including army teams), and some wore shirts in memory of people.

One thing that really touched me, was people who wore shirts in memorial of Shneior Cheshin (שניאור חשין). He was an athlete who trained for the Ironman Triathlon earlier this year, and was ran over by a drunk/drugged driver. That driver left him there to die, and made many excuses for that later when he was caught. It was a very tragic event which symbolized how careless are some people when it comes to driving responsibly and when it comes to ignoring injured people unless you know them.

Another thing which wasn’t possible to ignore, were “very big” people that decided that they need a change. I saw 2 like these, that made every possible effort to run, even if slowly. Even if it’s a bit late, I must admit it was impressive to see people who decided to change their life-style and participated in this race. I don’t know these people, but I wish them lots of luck.

Many thanks to the person who made me start running last august. They always say you need some motivator to start, and once you are in it it’s easier. She made me start (without knowing she did), and I owe her more thanks than I can describe in this post. Last year I was simply not in-shape, and I barely did 2-3 kilometers. In the last few months I took it seriously and improved to 10 kilometers.

Hopefully I’ll see you next year, On March 30 2012. I’ll do the half-marathon track (or if I’ll have enough luck, I’ll do the entire marathon)
Have a happy weekend :)

GIMP was accepted to GSoC 2011

2011-03-18T21:12:00.001+02:00

GIMP was accepted to Google Summer of Code 2011!

Congrats also for Inkscape, Blender, Scribus for making it to GSoC 2011! For the full list of projects, see GSoC 2011 participating projects.

First GIMP Developer Meeting - A success!

2011-03-01T00:59:00.002+02:00

I worked hard to arrange it, but it paid off - We had a serious gimp developer meeting, with most developers attending it :)

Thee meeting page, including the agenda and log can be found at:
http://gimp-wiki.who.ee/index.php/Hacking:Dev_Meeting_28_Feb_2011

Some of the decided actions in the meeting:

schumaml and LightningIsMyName fix wgo?
wgo is a shortcut for the GIMP main website - we need it to have auto-updates again
Alexia and mitch take care of redirecting wiki.gimp.org
We need to make the domain point back at a working wiki, the original one died of spam and Alexia Death has a new working one here
Enselic makes a draft of a GIMP roadmap and sends to gimp-developer
Let's get some priorities!
everybody subscribe to bug mail and TRIAGE BUGS
We get toooooo many bug reports, we need to start filtering them
mitch, make a development release soon
Yes - that's right! GIMP 2.7.2! Now we just need to define soon :P
LightningIsMyName takes care of next meeting
Hehe. I'll do that with pleasure :)
setting pages on the wiki to discuss changes in different topics
Too many changes are done solo and may not be agreed upon by everyone - this is because of lack of places to show plans
LightningIsMyName gets a list of projects on the wiki by tomorrow, developers review the ideas by email or by commenting on the wiki. Saturday (March 5th, 2011) is hard dead line for finalizing the project list!We want to get to GSoC, so we must have a list of projects ASAP! I'm going to work on this and try to get this done tomorrow night
all devs PM/Email LightningIsMyName username and email
Yeah, so if you are a GIMP dev and you don't have an account for the wiki yet, tell me!

Next meeting: March 14 2011 10:00 PM CET (GMT+1)

If you want to influence GIMP development, and/or contribute, come and attend the next meeting. Just note that the agenda will be decided by email several days ahead, on the developer mailing list - so submit your ideas there. You can also jump to irc://irc.gimp.org/#gimp and people will help you there if you want to help the GIMP project.

GIMP Developer Meeting

2011-02-28T11:48:00.000+02:00

Today (February 28th, 2011), at 10pm CET a meeting of GIMP developers is scheduled on the GIMP developer IRC.

Agenda:

GSoC 2011 - ORG Application deadline is in 11 days!
Bug fixing priorities
Future development?
Make an official wiki working again (i.e. make wiki.gimp.org pointing at it)! Can be done either by making http://gimp-wiki.who.ee/ the official wiki, or potentially using some other available servers (will be discussed in depth on the meeting)
Make a roadmap on the official wiki
Try and decide on clear release policy for beta builds - I personally would like to see more recent beta releases, and the last one was 7 months ago!
Anything else? =)

If you want to discuss GIMP's future, GSoC this year, and just listen, please come. We will meet on irc://irc.gimp.org/#gimp (Users without IRC client can connect using this link).

Edit: The wrong time was displayed - it's february 28th, not the 27th

My name is Antivirus. I hate Robots.

2011-02-26T15:28:00.001+02:00

I have a confession to make - I’m using an antivirus on my Windows 7 computer. This word may seem unfamiliar to some Linux users who claim they don’t need it, and to some Windows users who claim that these stuff are viruses themselves. It never did any trouble, and it did save me several times, but today it was just an annoyance.

I was programming a game for the course I took in Computer Graphics. When I ran it, it exited before the first line of code and I got the following series of warnings:

The error messages

My first cynical thought was “Great! I programmed a virus!”. My brother’s reaction was “Wow – your code sucks so much that an antivirus recognized it as dangerous”. So, I rebuilt the executable (after the antivirus kindly removed it for me :P) and then I tried to scan it. The result was “No threats found”. I got the result for all the libraries and files used by my program.

After scanning lead to a dead end, I tried to comment out my code and remain with a simple hello world program (which still loads the same DLL’s) – and I still got the error message.

So then I tried to google for help about this error in my antivirus and I found out that it’s generated by a dynamic protection mechanism, which unlike traditional antiviruses, does not check the signature of my files.

So, what on earth was going on? An “Hello World” program which does nothing was causing a problem because of it’s dynamic behavior, while other programs which used the same libraries were OK? That does not make any sense.

Took me 30 minutes to figure this out:

The theme of the game was robots. Since it was the Visual Studio version, the logical name for the executable was VSrobots.exe.
The word robot is often used for describing certain types of viruses and malware.
The only difference between this program and others which used the library, was it’s name.

So, I renamed the executable “HelloWorld.exe” and a miracle happened – it ran perfectly without any warnings from the antivirus.

Conclusion: Don’t name your executable files after things which may sound like viruses. Otherwise ****** Antivirus will block them :P

Note: I didn’t mention the name of the antivirus, to save some troubles that may raise because of it (mainly flame wars and other similar stuff regarding which antivirus is better – I have seen many wars like this in the web). Therefore, please refrain from posting the name of the antivirus in the comments, even if you recognize these dialog boxes.

It’s Open-Source, Live with it!

2011-02-04T18:34:00.003+02:00

Today, I saw something concerning, something which I think that I should share with you. Since GIMP’s call for help and developers, there was a small thread in the Blender Artists Forum that tried to raise support for GIMP, and make people aware of the lack of developers. While some replies were great to hear, and made me feel good as a GIMP developer, some simply pissed me off. Another event which amazed me, was to hear the reactions of some ungrateful people to ~~farsthary’s job offer from 3D Coat~~ (link is broken, he removed the post). I have to say that I’m a great fan of Blender, GIMP and Inkscape, and these are some of the most amazing projects that prove the ability of a community to build something together. But community is a double-edged sword – it can sometimes destroy things that took years to build.
Read more »

Compiling (Pre-Packaged) GIMP on Windows!

2011-01-30T04:35:00.002+02:00

Finally, after all the promises, I'm proud to announce that I finished the Guide for compililng (a pre-packaged version) GIMP on windows! The technique is using MSYS and MinGW, and without Cygwin - which means it's a native windows build!

What does it mean Pre-Packaged? It means a source package that you download from the website, and not the latest one from the version control system (Git in GIMP's case). Pre-Packeged version are not exactly the same you get from Git, and they passed an additional step that makes the compilation a bit easier. The additional steps for compiling the Git versions will be posted (hopefully) later this week.

On which version was this tested? On GIMP 2.7.1

The guide can be found here.
Update - fixed a small mistake which caused some stuff to be extracted to the wrong place.

Lessons learned from Writing a RayTracer

2011-01-19T12:14:00.000+02:00

As I promised in my post about finishing my ray-tracer, I'm publishing the math equations I used in order to save some time for other people, when doing the intersection calculations.

You can find the document here: The 3D Equation Sheet

And here is a list of ridiculously annoying bugs, that I encountered during writing the ray-tracer. Although some of these seem really trivial, I'll list them in hope that they will save you some time when you write a ray-tracer. Even though these seem trivial, I know that some of them are bugs that other teams also had.

Common Bugs:

When you shoot a ray from the eye and find an intersection, make sure the item is actually in front of the eye and not behind it!
When the ray from the eye intersects with a point, and you shoot light at the point, make sure the light is on the same side of the surface as your eye - so that you won't see light on the other side on opaque surfaces!
When calculating the intersection with a cylinder, which has a limited length - if the first intersection is "too far" from the origin of the cylinder, the second intersection may actually be in range! So check both...
Rays of light should be shot from the eye of the camera, and not from the image plane of the camera! (It matters when checking if an object is behind us or not)
When building the plane where x=6, the equation is x-6=0 and not x+6=0. Trivial, but not noticing this missing minus wasted an entire day for me…

[StructureGraphic] Drawing DAG's – Part 2

2011-01-17T23:26:00.005+02:00

As I promised yesterday in my first post about drawing DAG's, today I’ll describe a big part of the “nice-looking” graph layout algorithm. It’s very simple and it’s described in the following video:

If you are reading this blog from a feed, click the link to the real post to see the video

Corrections:

at 9:46 I said the result with iterating by the topological sorting would be uglier - I meant prettier...
I somehow switched the image of the best result from the graph… Here is the Correct Image Result

[StructureGraphic] Drawing DAG's – Part 1

2011-01-17T02:00:00.003+02:00

As I promised, it’s time to take StructureGraphic to the next level – drawing DAG’s. I have spent several hours today on formalizing what makes people think a graph layout is aesthetical, and how to make an algorithm that can draw a graph in such a way. You can see some quick sketches from the process below:

Quick: Just display connections, somehow
Better: Since it's a DAG, make all edges point down and try to
reduce the amount of edges that cross one another
Best: Align vertices to make it look better

A very complete guide about compiling GIMP (Linux)

2011-01-14T18:14:00.001+02:00

I have just published a very very detailed guide about compiling GIMP from source, with explanations of what does each step mean (instead of just giving commands for people to follow like dummies). You can find it here.

Corrections/Suggestions/Comments will be happily accepted!

Update (15 Jan, 2011): Added instructions about updating your build

StructureGraphic is now released!

2011-01-07T00:26:00.003+02:00

After a short betta period, in which I sent the library only to few people for testing, I'm now releasing the first public release of StructureGraphic! Students in the computer lab at my university are actually using this to debug their assignments in the data structures course - This makes me feel some pride :D

To those who haven't read the previous post about StructureGraphic, it's a library for visualizing data structures in java. Mainly, but not only, for debugging purposes.

Visualizations of a Binomial Heap (top) and a Red Black Tree (bottom)
Click to view fullsize

The project homepage:
http://code.google.com/p/structure-graphic/
Downloads (Library and Manual):
http://code.google.com/p/structure-graphic/downloads/list
Source Code (It's Open-Source!):
http://code.google.com/p/structure-graphic/source/checkout
Ohloh page:
https://www.ohloh.net/p/structure-graphic/

Feel free to dig into the source code and use the functions which are not yet documented. I'll complete the documentation of all the core functions later. Also, I'll try to make sure that any change in the library will be backwards compatiable - at least for the functions described in the official manual.

The library is currently licensed under GPLv3. If there are any projects which wish to use it, and have problems with that license, they can contact me.

Finished my Raytracer!

2010-12-29T00:37:00.000+02:00

Snowy Night
15K faces, includes reflection and phong normal interpolation

Above you can see the splash screen for my raytracer! Just handed it in, and overall I'm proud of myself (many thanks to my partner, the guru behind most of the lighting!). The code is very optmized (as much optimized as I can get without starting to write unreadable code).

Overall, I would summarize this assignment as something which I learned from - not only about graphics, but mainly about, how to optimize code (changing several lines for example made everything 3 times faster), how to debug properly and about writing larger scale programs (4000 lines is not gigantic, but it's bigger than anything I dealt with in the past, in which I knew what every line does).

The interesting part was writing the Octal Tree, aka Octree (Blender users should know what this is!). This was my first attempt at developing a high-performance data structure on my own, without any reference (there are many on google, but I used none). On the way I developed several optimization tricks (to make the tree less deep, to reduce the penalty of empty areas, and to overcome some other non-optimal meshes).

I really enjoyed most of this assignment (except for the part in which some of the reference renders had mistakes in them - wasting 6 hours because they have a mistake is NOT fun...) and developing most of the fast calculations for the geometry (not for the lighting) was fun.

The document describing the math which I used will be released later this week (as a starting point for people who want to write ray tracers), along with a list of annoying and potentially common bugs when writing a raytracer. Also an update about StructureGraphic - still waiting for the answer from the proffessor about hosting it the university. If he won't answer soon, I'll host it externally (any suggestions for code hosting sites or tips for choosing between github, launchpad, etc. ?). BTW, The next project in the course is writing a simple 3D game engine in OpenGL, and then writing a game with it :D

Announcing - Project LibStructureGraphic

2010-12-21T22:05:00.002+02:00

Note: This post is targeted mainly at programmers or people interested in visualization of data

As programmers, we often write very complex data structures. The hard part about maintaining complex data structures, is tracing bugs - since let's face it, in many places it's not practical to find which node out of several hundreds is deffected.

That's why I started a new project, called LibStructureGraphic. It's a library in Java, for visualizing data structures while making minimal or even no changes to their code. And since a picture is worth Ackermann(4,3) words (This is a programmers joke), here is an example:

Visualizations of a Binomial Heap (top) and a Red Black Tree (bottom)
Click to view fullsize

The idea is that having a visualization of the graph should help the programmer see more data at once, and speed up the times spent on finding bugs. I personally used custom code for drawing some data structures (for debugging) during my data structure course, and this was the source of this project. The visualization saved me hours of debugging!

The library requires a data structure to have the following properties in order to be visualized:

For now (will change in the future), the data structure must be representable as a Tree, which means it's composed of nodes where each node has exactly 1 parent and zero or more children.
Support for Directed-Acyclic-Graphs (DAGs) will be added in one of the next versions, and support for cyclic graphs is planned for the future
Each node of the data structure should be represented by an object, which either implements a given interface (for finding the "children", "value" and "color" of the node), or has annotations on the fields that should be drawn. Ideally, the annotations are the preferred way since they mean you don't need to implement any custom functions; The interface is there only for nodes in which it's not possible.
The nodes don't have to be of the same type - each node can be a completly different type of object!

The library will be released soon - I'm waiting only to see if one of the professors of my university will be willing to host it on its servers as an official project or not (Since this could be very useful in at least 3 mandatory courses). Non-Java versions (python, C#, C++, and potentially C with GObject) are not currently planned, but if enough people will want it, I will consider it ;)

And, the GIMP connection to this project (you didn't really expect me to write a post without mentioning GIMP, didn't you?) is that I'm working on a node-editor for GEGL. I knew I needed to implement a graph layout algorithm for it, and since I'm prototyping everything in Java, I thought of making a library from it.

Writing a Raytracer, and some other random thoughts

2010-12-15T02:05:00.005+02:00

I always wanted to write a raytracer, and theoretically I knew enough math and programming to do it for a long time. Yet, I didn't write one before - this is because I thought it would be a gigantic project. Well, I'm gald to tell you that at least a basic ray tracer is not too big!

The picture above is from a half-done ray tracer which I'm implementing during a course in computer graphics (which I'm taking now). I have documented the math that I needed, along with annoying bugs that I had (and I'm sure that at least some of these are common bugs).

When I finish this project in the following weeks, I intend to publish these documents. Currently I have:

A list of things which can cause annoying bugs, which are related to how ray tracers should work.
A document explaining many common 3D calculations (instead of taking these for granted, like we did in class).

I may publish more documentation about writing a ray tracer when I'm done - but this is just quick update about what I'm currently working on.

During writing the raytracer, I saw the influence of choosing the right programming language. We started with C++ and after we had memory leak that we failed to trace (even with valgrind and friends) we migrated to java (in which you have to work very hard to leak memory) - since it was the begining and converting the code was quicker than fixing the leak.

The debate about programming languages made me wonder - when GIMP 2.8 is finally out (and I'll start working on gimp again in the next weeks - I had too many things to do lately), and the writing of GIMP 3.0 starts, should we keep using C?

C is OK, as long as you know what you are doing, unlike C++ in which you can still make things crash even if you *think* you know what you are doing. I would really like to see GIMP in a higher level programming language, but it seems as if Java and C# are out of the question (patents, political/idiological reasons, ...). About a month ago, someone introduced me to Vala - a new OOP programming language, which works very nicely with the GNOME libraries, and it's translated to C code so that it works on most platforms.

I wonder if it's possible to convert the code gradually to Vala - and have the C code integrate with the converted Vala code. It is theoretically possible (I think, since Vala translates into C), I just wonder if it's practical, and what would other developers think about this idea.

Also, is Vala mature enough? And more importantly, Is Vala known enough? I did find several projects that use it, but when I tried to check how many people know it (asked fellow students in the university labs - sounds like the right place to ask) most people said they never heard about it.

Edit: See the comments below for a discussion for/against languages such as javascript/python/perl

New GEGL operation!

2010-11-06T13:11:00.000+02:00

Hello,

As I mentioned, I started working on some gegl operations, and I'm glad to announnce my first official gegl operation - whirl and pinch! This operation is a port of the known gimp plugin to gegl (since eventually every gimp plugin will have to be ported).

How to install it (linux users):

Copy the file operations/workshop/whirl-pinch.c (from inside gegl's source tree) into ~/.local/gegl-0.1/plug-ins/
Make sure your enviroment contains gegl's build dependancies
Type 'make' inside ~/.local/gegl-0.1/plug-ins/

Now, you will be able to access the operation inside gimp (using the "GEGL Operation" tool) and get a live on-canvas preview of it!

"Whirl and Pinch" live on canvas!

BTW - last night I closed 6 gimp bugs :)

Fixing errors with NAN (C const) and GCC

2010-10-21T00:47:00.005+02:00

Today, I was compiling GEGL on a computer other than my regular one, and I got this wonderful error:

exp-combine.c: In function 'gegl_expcombine_new_exposure':
exp-combine.c:149: error: 'NAN' undeclared (first use in this function)
exp-combine.c:149: error: (Each undeclared identifier is reported only once
exp-combine.c:149: error: for each function it appears in.)

The error happens only on certain machines with some versions of gcc, and I it may happen in the most unexpected times...
So, I thought I'd share the solution for this problem with you since I had it in several more projects which use the NAN constant. Basically, NAN is a constant for a floating point value, which represents value that is Not A Number (not to be confused with the value which represents infinity). This value is usually (see note at the end) returned when dividing zero by zero, and therefore it can be added to gcc's definitions by adding the following argument to the command line:

-DNAN="(0.0/0.0)"

This is equivalent to adding the following line in C

#define NAN (0.0/0.0)

Now, there is only a little problem - what if we are not running GCC ourselves? What if a makefile or some other utility does this? Well, with most configure scripts (These scripts prepare the build environment and generate the makefiles) you can simply set the CFLAGS environment variable (before running the configure script) to fix this - in bash syntax this would be:

export CFLAGS="-DNAN=\"(0.0/0.0)\""

This solved my problems :)
Reference - http://old.nabble.com/Where-is-NAN-Defined--td15398150.html, http://linuxreviews.org/howtos/compiling/
As the original email list say, NAN is defined on some platforms and it's undefined on others, and our definition may not always work. From my experience, in the few cases were NAN wasn't defined, the fix presented here was enough.

Edit: I’d recommend checking the first comment below, from Martin Nordholts – he seems to offer another legitimate (and possibly more elegant) solution by telling GCC to use the gnu99 C standard.

Guide - Upgrading Ubuntu 10.04 to 10.10

2010-10-11T04:09:00.009+02:00

This post describes the not-so-smooth update from Ubuntu 10.04 to 10.10. The "One Click Upgrade" did not really work here :P Took me several hours to get this right, and I used several backups to restore my system after bad attempts. Hopefully I'll save you some time and effort on how to do this =)

If the usual upgrade works for you, follow it - the steps here were done because the regular upgrade didn't work (slow internet connection, and some more problems).

Info: I'm running 32-bit Ubuntu, inside Virtualbox (a VM) under Windows XP SP3 host.
Read more »

Update - Multicolored text is now supported in GIMP

2010-09-02T01:36:00.000+03:00

Thanks to Michael Natterer (mitch) who had some time to do some cleaning to my patch, and integrate his patch to allow true rendering of color for text (instead of rendering an alpha mask) GIMP now supports multicolored text :D

Go test it from the latest source and report bugs if you find some ;-)

Some thoughts on hunting bugs (Software in General)

2010-08-30T23:37:00.005+03:00

I don't tend to complain too much, but it was annoying as hell to track down this bug, so I though I'll share some of the joy with you =) This post is mainly for software users (not GIMP-specific) as it should give you an insight on how to track the exact cause of a bug, and so make better reports and make it easier for the developers to fix the bug =)

Developers may also enjoy this post - thinking about this bug and how I tracked it, it is in fact a very funny bug :D

Read more »

GIMP can now export PDF's!

2010-08-28T00:34:00.006+03:00

Hello!

After some work, I'm proud to say that GIMP can now export PDF's using my new cairo-based pdf export plugin!
Go check it out - it's in the main source repository in the master branch :D

Comments and feedback are more than welcome - you have until 2.8 to affect how this plugin will work and which features it will have. Currently, it has:

Support for multiple pages using multiple images using File->Create->Multiple-Paged PDF...
Support for exporting text as text!!
Support for resolutions

And it has the following optimizaiton options:

Replace rectangles of a single color with a vector shape. This can dramatically decrease the file size (think of all the single-colored background layers that are now saved as vector instead as bitmap)
Remove the alpha channel of layers where it's unused, to decrease the file size
Discard layers which are not visible or are100% transparent
Can either apply layer masks (to decrease the file size) or keep them (better quality pdf, bigger file size)

Happy Gimping!

Edit: Updated the post with details on the plugin

That's it! No more exams!

2010-08-11T16:49:00.001+03:00

Finally, I finished all the big university exams :D
This means I can now start to work on GIMP much much more time. As I said in my previous post, We need some feedback from the GIMP community =)

These two months until the next semester will also give me some more time to put into music and photography - two things whwich I haven't dedicated enough time to lately...

Some updates + Feedback Needed

2010-08-10T21:32:00.002+03:00

As I said in my previous post, I'm a bit inactive due to the tests which I had in university. After finishing Logics for Computer Science, tomorrow I have my last test - the dreaded Calculus 2...

So starting tomorrow noon (it's night here right now), I'm back on full time GIMP coding! Here is what I'm up to, and reasons for some delays:

Multicolored Text Layers
On their way - no real reason for a delay, I just need to fix some (hopefully) easy bugs :-)

Where is the PDF plugin which you promised?
A new API is being introduced into GIMP - an api for accessing layers, channels, masks and paths - all as GimpItem objects. I want this api to be finished before I'm done, so I'll write the code once.
Also, it's currently impossible for plugins to access the layers inside layer groups - instead they get one layer which is a merged version of all the group. This means that text as text will be ruined if it's inside a group, so I'll wait a while to see if there is any chance it will be fixed before I continue.
Finally,it's probably better to finish implementing the multicolored text patch, so I'll be able to test the pdf plugin when it's already integrated =)

Angular Guides - Feedback Needed
Before you get excited, don't. I'm checking the option of adding support for guides with arbitrary angles inside GIMP (instead of only horizontal and vertical like now). I'm in doubt this is going to happen soon - I had a day to play with the code a bit, but nothing more.
Someone (mitch if I remember right) suggested to implement the new guides system as paths; You can currently snap to the active path as if it was a guide (View->Snap to active Path) - that's a less commonly known feature. Anyway, Implementing it this way will possibly allow us to add things like isometric/polar grids and other snapping shape we can imagine. So even if this sounds harder, it's worth a check.

Here is where I need your feedback on:

What kinds/shapes of guides/grids would you like to see in GIMP?
Do we need guide groups (for enabling/disabling many guides at once)?
Other guide related requests?

I don't promise anything yet, but if I'll know what I'm aiming for before I begin, it might help :-)

Usability of GIMP's menus - Feedback Needed
Finally, there have been a discussion on the usability of the GIMP menus. There were discussions about adding searchboxes to search GIMP's menus (since these can get cluttered if having many plugins).

Here is where I need your feedback on:

Would you like to be able to categorize your plugins? Or maybe tag them and browse by tags?
Do you need to be able to edit the categorization of an existing plugin (if such categorization exists)?
How would you like to search for a plugins/built-in functions? What should appear next to the description of each action/plugin?

I'll raise some of the suggestions on the discussions in the mailing list or the developer's IRC. We need your feedback! If we want to make GIMP better for the users, we better hear them =)

[Quick-Tip][GIMP] Rounding any selection

2010-08-02T15:58:00.003+03:00

One thing I was asked how to do several times, in GIMP, is how to round a selection which is not rectangular. For example, if you have start shaped selection and you want to round it's corners - how do you do this?

Today I'm going to show you a quick and dirty way to do this:

Load the selection that you wish to round. Save it to a channel so that you will be able to undo what we are going to do.
Step 1: Load the selection
Shrink the selection by the radius you want to round it (i.e. if you want to round your selection by 10px, shrink it by 10px).
Step 2: Shrink the selection
Create a new layer. Now stroke the selection with round caps/joins and set the stroke width to double the radius of the rounding (Since I shrunk the selection by 10px, I'll stroke it by 20px).
Step 3: Stroke the selection
Note the settings of the
"Cap/Join Style"
Fill the selection (on the same layer you stroked the selection).
Step 4: Fill the selection
This is how your layer
should look (without the
selection)
Now, transfer the alpha of the selected layer to the selection (aka "Alpha to Selection") and delete this temporary layer.
Step 5: Transfer the alpha
of the layer to the selection
and get rid of the layer

That's all - A very neat result, even if the technique is a bit ugly :P

Tip: If you want a smoother result (some of you may notice small jags on the resulting selection) try the following instead of step 3:

Convert the selection to a path (aka "Selection to Path").
Deselect the image.
Stroke the path (with the same settings as above).
Make a selection from the path and delete the path.

Does anyone want a script to automate this? If so, leave a comment and I'll write one =)

Help Us Help You! A short guide on reporting (GIMP) bugs

2010-07-27T00:31:00.004+03:00

Hello,

After a recent increase in the amount of bugs which are reported on the GIMP bugzilla, I thought it might be a good idea to give some helpful tips about reporting bugs in GIMP (and in general in most open-source programs) - these will help us the developers to help you:

In case of broken functionality, please try to:
- See if you can reproduce the problem. If you can't reproduce it maybe it's not a bug.
  Try different scenarios to reproduce the bug (i.e. try reproducing it with different images or with similar settings of the tools/plugins/etc.)
- List the exact steps which are needed to reproduce the bug. If we don't have the steps, we won't be able to see the bug ourselves.
- Tell us the exact version of GIMP (you can find it in the Help->About menu)
In cases when GIMP or one of it's plugins crashes, we'll need more technical details about your system (in addition to the details about broken functionality):
- The name of the operating system you are using, and it's version (for example "Windows XP service pack 3"/"Ubuntu Linux 10.04")
- For advanced users: try to provide a stack trace. To do this, launch GIMP from the command line, with the flag --stack-trace-mode=yes. Now when GIMP crashes, you'll see a question in the terminal asking you if you want to print a stack trace. Print it and attach it to your bug report.
- For regular users: Launch GIMP from the command line (if you know how to), and if any error is shown when GIMP crashes, attach it to your bug report.
Enhancement requests are not bugs.
If you have an enhancement request you can post it on any of the following places:

GIMP Developer mailing list: (see this page for more details)
GIMP Developer IRC channel: irc://irc.gimp.org/#gimp
GIMP User-Interface Brainstorm blog (For enhancements/suggestions for the user interface only and not for general enhancements)

Finally and most important of all: Check if the bug was already reported. Unless you are using a development release, it's very likely that the bug you encountered was already reported by someone else.
You can search for existing bug reports using the search form on the bugzilla page of GIMP. Try entering some key word related to your bug and see if it was already reported.

For more information about submitting bug reports to GIMP, see the GIMP bugs page.

For your convenience, here is a list of commonly reported bugs of the last month:

Bug 623563 - Text tool crashes Gimp
Bug 622608 - GIMP crashes when clicking any scroll bar from combo boxes
Bug 606247 - Crash using rectangular select tool with fixed aspect ratio on Windows XP
Bug 624089 - Copy-paste doesn't work (GIMP 2.6.10 - Resolved and fixed)

Thanks for reporting bugs and thanks for taking the time to read this post - it will help us help you! =)

Edit 13:27 IDT (GMT+2) 27.07.2010:
To make it clearer (as it was pointed out by peter sikking): The GIMP UI brainstorm blog is only for enhancement requests for the UI - i.e. ways to make the user interface better. It's not for general enhancement requests.

GIMP suggestion - Improved Gradient Tool

2010-07-19T22:40:00.000+03:00

A quick suggetion for GIMP's Gradient Tool (Maybe I'll have time to implement it sometime :P):

A quick UI Mockup
Click to view in fullsize

Basically there are two things I always wanted to do with the gradient tool:

Shift a gradient so that it's end wraps to it's beginning (See illustration)
Colorize a gradient using an external color - This can be used for all the glossy/metalic gradients; Simply create one grayscale gradient and apply the right color each time.
Alternatively, instead of colorizing a gradient, add an option to rotate it's Hue - this might be even more powerful since this will support even more user cases.

Notes:

The first suggestion can not be accomplished currently in any trivial way, except for creating a new shifted gradient (yuck!).
The UI for the second suggestion needs some work - Where would we display the updated gradient? Directly on the usual preview area or in a separate view?
The second suggestion doesn't bring any new capabilities - it can be currently done by using the gradient tool and then using some color tool. But, the one step approach is far more easier.

Progress - Multicolored text layers in GIMP

2010-07-12T23:39:00.004+03:00

Hello again,

Before I vanish to study to some more unexpected tests here is a small update on multi-colored text layers. mitch (Michael Natterer) has fixed up a patch, which now allows the text core to render multicolored text! Until now, text in GIMP was rendered as an alpha mask for a color layer which prevented my patch from being any good. The original reason for this, was to avoid having to handle images with different color modes (indexed/whatever) by rendering only the shape as a mask.

So, I tried my patch again today. It works, if you want gray text :D I have some issues with the conversions, but the patch basically works.

I did say it basically works - even if it's not the color you expected :D

For those of your who want to try this out, here is the bug report Bug 620674 - Adding support for multi-colored text layer. There are two patches attached - one patch by me which adds the functionality in the gui/core for specifying several colors in one layer, and the other patch (by mitch) which enables rendering of the text-layout itself instead of using it as a mask on a color layer.
Download both patches to the directory with the source of GIMP, and run the following commands in bash:

cd GIMP_SOURCE_DIRECTORY # replace with the actual path
patch -p1 < MITCH_PATCH # replace with the actual path to the patch file
patch -p1 < MY_PATCH # replace with the actual path to the patch file

Now re-compile GIMP and enjoy =)
The color selection yields the wrong colors (bright shades of gray) but it works.

I'll be back next week hopefully, but it may take a bit more time (Big exams...)

p.s.
I see that a very big fraction of the readers of this blog are from Russia - so спасибо! (For English speakers, that's thanks in Russian)

Multithreading in GIMP, Learning to write GEGL operations

2010-07-11T18:04:00.004+03:00

As some of you have seen, GIMP is being ported to a new graph-based image core, called GEGL. Those of you who have experimented with GIMP 2.6.X and later, have possibly found the GEGL tool (Under the tools menu) which allows you to see on-canvas preview of some operations such as blur, perlin noise (which some of you know as clouds), and more.

Thanks to the very generous help of Øyvind Kolås (aka pippin), I have started to write a GEGL operation for GIMP. Too practice I decided to write a Pixelize operation (not too complex, but also works on a neighborhood of pixels and not on a single pixel).
This is the first time which I implement an image processing algorithm which is not based on samplings for distortion (like the waves filter), and although I know the theory for a lot of time, it still has some bugs with wrong indexes :P

When I finish this, I'm going to post it here along with a log of my chat with pippin on the IRC (on irc://irc.gimp.org/#gegl) to clear out some of the common questions about GEGL. Hopefully I'll be able to post a mini-guide (or more correctly, what I have learned, since I still have a lot to learn to write a full GEGL guide) to introduce other people to writing GEGL operations.

The discussion originally started because I was disappointed that libgimp (the library for interactions between plugins and GIMP) is not thread-safe, meaning that you can't have two threads modifying the same drawable concurrently (unless of course you want to "Create ~~Modern~~ Random Art" as someone called it). And it's ~~impossible~~ not practical to fix it (due to the amount of time it would take).

Apparently, GEGL is multi-threaded (more on this later, in my next post) and it usually works (but sometimes the threads reach a dead-lock, a situation in which both threads are blocking one another from progress since they are waiting for shared resources/memory). It still requires a bit of fixing (Cheer up for pippin! He needs some more motivation to fix this! ;-) )

So, for those of you who want to try "bleeding edge" and unstable GEGL, set the environment variable GEGL_THREADS to 2 (or whatever amount of threads you want GEGL to use) and expect up to 200% speedup (in ideal world. Practically some parts of the code which are executed sequentially, added to the limitation of the memory access speed, both will cause it to run slower depending on the operation and your system) with GEGL (or 0% if you reach a deadlock).
Be warned: this is supposed to be buggy. Please do not report bugs with this, unless you strictly know what you are doing.

Edit: Made the post more correct about the possible speedup. 200% speedup is a naive optimistic view, which is ain't true (and I forgot to mention this)

GIMP 2.6.10 [bugfix] is out

2010-07-09T03:14:00.000+03:00

GIMP 2.6.10 is out and it's a bugfix release. The time between this release and the previous one was a bit short because of an annoying bug that was discovered...

Overview of Changes from GIMP 2.6.9 to GIMP 2.6.10
==================================================

* Bugs fixed:

 613328 - TGA files saved with incorrect header yOrigin data
 623290 - Save As... does not save Windows Bitmap as default in dialog
 621363 - CMYK decompose broken
 595170 - brush - color from gradient works wrong in greyscale
 613838 - Error in gimp-hue-saturation PDB call
 622608 - GIMP crashes when clicking any scroll bar from combo boxes
 565459 - newly opened images are put into the background

* Updated translations:

 German (de)
 Italian (it)
 Romanian (ro)
 Portuguese (pt)

So, what are you waiting for? and grab the update ;-)

Updates

2010-07-08T10:03:00.002+03:00

I'm back - Finished all the university tests finally!
Some updates:

I got myself a working windows computer again on which I can test the compilation of GIMP - and this time it much faster (last time it was a computer with a disk access throught the network and the connection speed made the compilation 24 hours long...). I'll try to get this fixed as quickly as possible (and the IT at the university are trying to find me an even better windows computer).
I missed the 2.7.1 release with my PDF plugin - I had too many tests...
Decided to be a bit artistic - I submitted the new icon for the cage transform tool - you can take a look at it here.
After finishing my course in Multicore Programming, I decided to try to do something practical with it. I'll be experimenting with multicore plugins for GIMP over the next week and I'll see what's possible (if any).

GIMP 2.6.9 + Hebrew Translation Update

2010-06-24T21:10:00.000+03:00

Hello everybody =)

For those who haven't seen yet - GIMP 2.6.9 is out!
Go get it! The release notes are here.

Also, I commited my first Hebrew translation update. About 1/6 of GIMP's main gui is translated.
Want to help translating? Have comments about the translation? Comment here (or leave a bug report if it's a translation bug).

Gimp Updates: Multi-Colored Text, PDF Export, Hebrew Translation and more...

2010-06-20T22:08:00.002+03:00

Here are some quick updates from the last several days:

First announcement: GIMP is currently being translated to Hebrew!
As a Hebrew speaker, I was very disappointed from the state of the Hebrew translation of GIMP. So, I decided to start and translate it, and I already fixed several bugs to make the translation to Hebrew easier.
The translation is going on well, and I'll start updating the main git repository with the translations soon.
I have some progress on the PDF export from GIMP. Hopefully it will be committed this week - all the blocking issues were resolved and basically all I need to do is to connect the GUI.
I did try to implement multicolored text support in GIMP (several colors in the same layer) and it failed for the most annoying reason - text in gimp was rendered as an alpha mask for a color layer.
Mitch fixed it recently, so this means that I'll be able to retry my patch somewhere soon.

And finally, I have to say that I'm quitting (at least for now) the attempt to save single window mode layout in GIMP. It's not so practical right now, since the object which hold the data (GimpDockWindow in swm and GimpColumn in mwm) are being destroyed when switching between modes.
After discussing it with Martin, I understood fixing this is not trivial, so I'm not going to do it anywhere soon...

Updates and Flies

2010-06-18T14:06:00.002+03:00

First of all, before I forget, many thanks to Alexandre Prokoudine who added this blog to GraphicsPlanet. Go check this site - it lists blogs of many open source projects and their developers.

There is more progess on the single window mode - saving it partially works now (or more correctly, loading it works). The post about the single window mode is updated as I make progress in that direction.

The blog is now printer friendly, at least for firefox users - please notify me if you see anything which doesn't look well in printing.

And finally, this blog is also about art and photography. Here is a picture I took today, which I like (click to go to the page with the fullsize view)

2fly by ~LightningIsMyName on deviant ART

Script of the week - Creating HTML documentation for the GIMP PDB

2010-06-17T11:50:00.000+03:00

Someone asked on IRC for this, so here it is: http://www.pasteall.org/13829/scheme
This script generates HTML documentation from all the GIMP PDB.

To use it, simply call (db-to-html-file FILE) in the script-fu console (replace FILE with the path for the file you want to create).

Progress - Saving Single Window Mode settings in GIMP

2010-06-16T00:50:00.011+03:00

Two days ago, I promised to try and work on the single window mode in GIMP. Well, I have worked on it, and I know basically know what needs to be done.

Note: This post is mainly for people interested in the GIMP's source. For others, just take my word that there is some progress =)

So, how is single window mode implemented in GIMP?
The heirarchy is the following:

The heirarchy of the user interface containers inside GIMP
GimpDockable's inside GimpDockbook's inside GimpDock's

GimpDock - which is very similar to a GtkVBox
|-- GimpDockbook - this is a small area which allows tabbing of several GimpDockable's
|--GimpDockable - This holds the actual content and user interface elements

Single window mode, introduced two new containers - left and right. In each of these 2 new containers, we can store several GimpDock's in a row (see the image from my previous post, to see how this looks).

Here is a typical part of the sessionrc file, a file in GIMP which holds your session preferences:

(session-info "toplevel"
    (factory-entry "gimp-dock-window")
    (position 0 25)
    (size 200 523)
    (open-on-exit)
    (aux-info
        (show-image-menu "false")
        (follow-active-image "true"))
    (gimp-dock
        (book
            (current-page 0)
            (dockable "gimp-layer-list"
                (tab-style icon)
                (preview-size 32))
            (dockable "gimp-channel-list"
                (tab-style icon)
                (preview-size 32)))
        (book
            (position 236)
            (current-page 0)
            (dockable "gimp-color-editor"
                (tab-style preview)
                (aux-info
                    (current-page "GimpColorSelect")))
            (dockable "gimp-brush-grid"
                (tab-style preview))
            (dockable "gimp-pattern-grid"
                (tab-style preview)))))

So, here is a short analysis of what's going on:
(session-info "toplevel"...) - means we are talking about a top-level window
(factory-entry "gimp-dock-window") - means we are talking on a dock window (other windows are also saved, for example the location of the save dialog)
(current-page 0) - means that the current open tab is the first one
The rest is pretty self explanatory...

So, how am I supposed to implement saving a single window mode?
"Simply", add two parameters directly after (factory-entry "gimp-dock-window"). This entries are single-window-mode-position which can be one of "left", "right" and "floating" (since you can still have floating docks in single window mode). And, for docks which have one of either "left" or "right" value, I'll have to add a "dock-index" property which indicates their index in that side (left/right).

Here is the bad part - I'll need to add these configuration properties to the docks themselves, and to the configuration file. Then, I'll also have to support parsing these parameters when activating single window mode. This is going to be long, and annoying but it also has a bright side - I know how to do this =)

And with this somehow optimistic summary of what needs to be done - I'll go to sleep (I should really find times to update this blog during the day instead of writing at midnight :P).

Edited - Jun 16, 3:59 AM:
1. fixed a wrong class name inside the image of the gui
2. Got thumbs up about this way of implementation from martin (aka enselic) - the guru behind the single window mode.

Edited - Jun 18, 12:22 PM:
Loading the settings of single window mode works! BUT, saving them doesn't :-( The problem is that if we are currently in single window mode, dock windows are not saved at all (even the fact that they exist is not saved).
I believe they (the dock windows) are being destroyed during the switch to single window mode, after the dockables inside them were attached to the "uber" image window (that's how it's called in the code, I haven't chosen uber myself).
If I'm true, this will also explain why when I quit after switching to single window mode, the settings that were loaded for single window mode, are lost (since they were associated with the dock windows and these were destroyed).
There is no easy way out of this - I am starting to understand why mitch said this problem is so evil...

Single window mode - wonderful for the user, horrible for the developer

2010-06-13T04:18:00.000+03:00

Some of you may have seen the single window mode introduced in 2.7. It's wonderful to use (no need to suffer anymore from the huge amount of floating docks!). You can dock all the dialogs on the sides and customize the location and size of every one of them. All, inside the main window!

New features in this screenshot are layer groups, resource tagging, on-canvas text editing and on canvas dialogs, single window mode and paint-dynamics dialog (you can configure each dynamics settings in more way than you can imagine :D)

But, here is the catch - you can't save this layout! Every time you start Gimp, you will have to go to Windows->Single-Window Mode to enable this, and the location of the docks won't be saved. In other words, you have to rearrange the window layout every time, when using single window mode.
And to make it worse, when trying to fix this mitch warned me:

you actually picked the most evil current problem ;-)

Having to set your layout again every time IS VERY ANNOYING. I'll try to fix this, but after looking at it I'm sure it's not going to be easy. Oh well, someone has to do this =) Starting this at the middle of the night (an hour ago) wasn't so smart - I'll go to sleep and do this (or at least try to) sometime during this week...

Made my first commit to GIMP - and haven't ruined anything :D

2010-06-12T21:31:00.000+03:00

I just made my first commit to the GIMP git repository, and luckily I haven't ruined anything (it's pretty easy to ruin things with git).

Many thanks to Michael Natterer (aka Mitch) for helping me with this, and generally with helping me with diving into the GIMP internals.
If you are reading this - I owe you so many thanks ;-)

Got my Git Commit Acces!

2010-06-11T21:05:00.001+03:00

I got my commit acces to gnome git! :D
This means a lot to me =)

GIMP is alive, even if it doesn't look so

2010-06-10T22:32:00.002+03:00

Recently, there was a mail to the gimp mailing list, that suggested selling some gimp stuff in an online shop in the gimp website (gimp stickers, mugs, T-shirts, etc.). I like the eidea, but this isn't what I came to discuss todau. Here are 2 quotes from the responses that the suggestion got:

On Wed, Jun 9, 2010 at 8:27 PM, Alexandre Prokoudine wrote:

One of the things discussed at LGM was moving all project's domain and subdomains to a single dedicated server. We have a person willing to do the migration and a person to create a new website.

On Wed, Jun 9, 2010 at 8:50 PM, Michael Schumacher wrote:

We're currently unable to update the website (if you have a look at the index page, even the release announcements aren't up to date).

Until this is resolved, we won't be able to add, edit or remove anything to, on or from http://www.gimp.org/.

Some of you are probably going to respond like this: "WTF?! You have a website and you can't update it?!". My response was also something of that style. As developers of open source projects, we don't need the main website to know it's alive. However, the gimp user community probably think that this project is dead (6+ months without a single update of the site, not even about a call for students for Google Summer of Code!).

So, after some discussions yesterday, in a thread that I started (and you can see the conversation here) several things happened:

The maintainer of the server was contacted - the site is going to be fixed soon (Thanks to Alexia Death that started working on it recently, even before this mailing session). Although the actual length of "soon" may vary, it's on the TODO list.
The idea of some sort of developer blogs was raised, and several people volunteered to update them (including me). We'll have to see how does updating the site goes, and maybe we will create these blog(s).
There was a recent discussion about weekly/daily builds. These builds will serve us by allowing other people to find bugs, and it will serve the community by showing them the latest developments (and that the gimp project is still alive). It wasn't decided yet if there will be such builds - some developers object (since this can generate many useless bug reports if people who don't understand gimp will try the betta) and some support this (since people are already using such builds, so let's make it controlled so we get reports from builds in controlled enviroments).
New builds will hopefully be released soon:
- A new stable version release 2.6.X with some more bugfixes
- A new unstable build, 2.7.X to replace the old one. This will allow users to see the new features and report bugs so we can fix them. Hopefully, there will be more frequent unstable builds.
Again, keep in mind that the definition of soon is very flexible...
I'm going to post an offical guide on compiling gimp on windows, on the main gimp developer website. This will probably help the people out there who want to try the latest versions, but are using windows (like me) where it's almost impossible to compile gimp :P

And now for some personal updates:

Still waiting for my commit acces to the gimp git - I applied a week ago.
The PDF export plugin, which I'm working on, will take a bit more time due to the exam period from the unversity.

That's all for today =)

2010-06-06T00:21:00.001+03:00

public class Test
{
    public static void main (String[] args)
    {
        System.out.println ("Hello World");
    }
}

Site updated!

2010-06-02T23:58:00.000+03:00

Finally - a template which I like =) (customized one of the predefined templates)

Some updates:

Had a talk with Peter Sikking today (aka guiguru at gimp IRC) about the UI of the pdf plugin (I'm writing a PDF export plugin for GIMP). Expect to see it in GIMP's trunk(!) later this week.
I'm working on a translation of GIMP to hebrew - this will take some time but I hope to find some users for it
I'll have this blog posts available both in hebrew and in english, when I start posting tutorials

Hello World

2010-04-06T03:07:00.000+03:00

Hopefully this will be my new website =)
I'm a student for computer science at Tel-Aviv University and my interests are

Computer Graphics
Digital Art
Photography
Music
Programming

I try to contribute to the open source project GIMP, an advanced image-manipiulation and image authoring program. (some see it simply as a free alternative to photoshop)

Hope this time I'll keep the site maintained :P

Squeezing your Filesize (KB) - Tutorial

2008-06-25T14:48:00.003+03:00

There are lots of cases where you want to squeeze a picture's filesize. Sometimes a small picture can be 250+ KB while a bigger picture can be only 10KB. This is because of the different filetypes.Today I'm going to teach you, how to choose the optimal filetype for your picture.Although this tutorial uses GIMP (all the instructions about plugins and menus are for GIMP), this should help users of other programs that have basic understanding of their program.Read more »

GIMP Path Tool (aka Pentool) Tutorial

2008-06-15T15:36:00.005+03:00

In this tutorial, you will learn the Path Tool (aka Pentool) in GIMP. The Path Tool is used to create complex shapes and curves. Many people don't use it since it's too complicated, However today I'm going to show you that it's not.
Note: This tutorial was transfered from my old website, and it's now updated with more information
Read more »