DOWNLOAD: ThinGit Update

As the name suggests, it is – similarly to SparkleShare – based on Git. To be precise – the idea behind it is identical, so all tutorials for setting up a repository for SparkleShare are also valid for ThinGit.

ThinGit is completely self-contained (requires only Java) and comes in a single JAR file 1.8MB in size. Under the hood it uses JGit (for Git repository handling), JSch (for SSH access), cli-parser (for command-line arguments parsing) and – interestingly – AspectJ. Yes – for the first time ever I actually found a good application for AspectJ. I used it to inject code that sets HTTP proxy for SSH sessions created by JGit (functionality which is unfortunately not exposed by JGit API and it wasn’t possible to set a default proxy using JSch API either). ThinGit was originally a command-line only tool (compare pics 1/2/3) and actually can still be considered command-line in nature because the minimalistic GUI I’ve prepared basically just helps you set the proper command line arguments (and remembers them for future use). To adhere more to industry standards, it also features a tray icon and notifications about repository updates in balloon tips (pic 4) but that’s it – lean and mean, as promised

Now, let me describe briefly the list of parameters:

Paths containing Git repositories to be serviced – this is a list of paths on your local filesystem with Git repositories that you wish to have handled by ThinGit
HTTP proxy host/port/username/password – these parameters specify the HTTP proxy to be used; if host is not set, the others are ignored
Username to be used in case of interactive authentication – CLI-only – specifies the username to be used for remote SSH connections
Ask for password to be used during interactive authentication – CLI-only – makes ThinGit ask for password at startup; this password will be used for all authentication purposes later
Delay between synchronizations (in milliseconds) – Delay between consecutive cycles of synchronization; it’s a matter of personal taste, reasonably can be anything between 10 seconds and 10 minutes; note that if both sides have this delay set to 10 minutes, the worst case delay between side A updates getting propagated to side B is 20 minutes!
Disable graphical subsystem – forces use of CLI; normally ThinGit tries to launch GUI and only if it fails, falls back to CLI
Clone selected repository – this argument takes precedence over -repos; if it’s specified ThinGit will perform a git-clone command on the selected repository; normally you will launch ThinGit once with this parameter set and then clear it and set -repos instead
Target path of cloned repository – target argument of the git-clone command
Cycle once through repositories and exit – don’t loop the execution, process all repositories once and exit
Show configuration dialog – Unused
Set Java look and feel – GUI-only – Sets Java Look and Feel, possible values are windows and gtk; you can also set LAF using Java’s standard -Dswing.defaultlaf= switch. Requires restart!
Start as tray icon only – GUI-only – Starts application without showing the main window

Noteworthy, JGit, and thus ThinGit processes ~/.ssh/config file so it is possible to set up a password-less key-based login to your repository server! In my case, the whole setup was like following: I’m running an Apache server with mod_proxy limiting access by IP and AllowCONNECT set to Yes and SSH with key-based authorization. My ~/.ssh/config contains appropriate entries. My key is password protected so I have to enter the password each time ThinGit starts. I configured proxy first giving algoholic.eu as host and 80 as port, then I ran ThinGit with -clone set to algoholic.eu:/tmp/git1 (my test repository) and -clone-dest set to C:/tmp/git5. After it completed cloning, I ran it with -clone parameter removed and C:/tmp/git5 added to -repos.

And that was it! Now I have it running on my test repository for 24 hours already and it’s doing nicely so far. It’s doing such a good job replacing my pen-drive that I’m actually going to establish a more permanent repo and hold all my small projects together in there. I was growing tired of creating separate Git repos for each small thing and keeping them without any versioning is also quite bothersome, so I welcome my own new creation

As you can see (pic 5) a repository serviced by ThinGit can still be accessed by regular Git tools (in this case – GitExtensions) allowing for easy history management.

To summarize the rationale and benefits of ThinGit:
1) Self-contained Java-based application – just one small JAR file for every platform (also Windows XP ) supporting Java SE. It’s by far the smallest application of this kind!
2) Supports HTTP CONNECT proxy – in my experience, the most reliable way of circumventing firewalls (SOCKS proxy are supported using Java’s -DsocksProxyHost=socks.mydomain.com switch)
3) Command-line and graphical interfaces that map almost 1:1 allowing for execution in environments with or without graphical subsystem.
4) You can use existing Git tools, including Git-based sharing/collaboration applications like SparkleShare in an interchangeable manner (e.g. when you need to access your repository from Android, SparkleShare might be the right choice!)
5) And of course this – part 1, part 2

I recommend ThinGit to those who are concerned with security and for some reasons have trouble running SparkleShare or just like a lean-and-mean solution like ThinGit more. Enjoy!

DOWNLOAD: ThinGit (JAR file inside ZIP)

Now to SparkleShare – unfortunately, I’ve learned the painful way (immortal ‘Program has ended unexpectedly…’ message) that it is unsupported on Windows XP !!! That’s a major issue in my opinion but never mind – I gave it a try anyway on another PC running Windows 7. SparkleShare’s user interface looks quite nice and provides easy wizard-based configuration. We can have SparkleShare handle Git projects hosted on our own server or any of the free Git hosting providers: Bitbucket, Github, Gitorious or The GNOME Project. However, all seems nice and well only as long as you’re not behind a firewall! I’ve tried to add a project hosted on my own server and failed miserably. For all the free hosting providers SparkleShare also tries to use SSH and fails. And there’s no option for HTTP proxy configuration (this is what I normally use to punch through to my server). Ouch! That’s painful – I can’t really test it now, can I? ;/ Actually I can but since it requires some extra steps, I will let it rest for now.

It was all anyway to prepare the stage for a new player – my very own thin-git ; ) More about it in the next post. It actually works where SparkleShare failed!

Dropbox employees are prohibited from viewing the content of files you store in your Dropbox account, and are only permitted to view file metadata (e.g., file names and locations).

you know what? I just don’t believe them! Also, just take a look at the DropShip story and imagine how much data could’ve leaked this way. So sure… I don’t mind you using DropBox – I wouldn’t even mind using DropBox myself for storing some multimedia files – but I definitely think you’re crazy if you keep your business or research data there and I would for sure never go with such solution myself.

However, criticism without any suggestion of alternative solution is worth close to nothing, so I started looking for a free and open-source DropBox-like applications. Almost instantly I found SparkleShare which mimics precisely functionality of DropBox – it is multi-platform, has user-friendly GUI, supports file sharing and version control . What’s more – it let’s you set up your very own server! To that end you only need a machine running Git VCS and SSH!!! SparkleShare’s architecture is trivial and powerful at the same time. Basically it’s just having a remote Git repository and its many clones and SparkleShare running git commit/fetch/rebase/push periodically on all of them with automatic conflict resolution based on timestamped copies creation (i.e. whenever there’s a mid-air collision, one version is given a new filename with timestamp appended, the other one is left as it was). Standard Git parameters are tweaked to accommodate your files which will typically be a lot larger than text files Git normally works with. All in all, SparkleShare claims to be an efficient and robust solution.

Now – I admit I haven’t really tested either DropBox or SparkleShare ; ) I know, I know… how can I have an opinion, right? ; ) Just to be on the safe side – I will give them both a try on Monday. In the meantime however, I have prepared my own SparkleShare-inspired piece of code

It’s called thin-git and at the moment is just a console-based tool (no GUI). However it could already replace SparkleShare in terms of functionality. Why a new application instead of contributing to SparkleShare? Well… I wanted to create a Java-based solution relying on JGit only so that you could use it without having to download the original Git tools. Actually both DropBox and SparkleShare fall short of my liking because of the libraries they use. DropBox is based on wxWidgets and SparkleShare/Linux on GTK# (and probably System.Windows.Forms for Windows). In other words – as usual, I wanted to offer something lean and mean as alternative to existing bloatware-ish solutions : )

Stay tuned – I will soon describe my new piece of software and the impressions after using DropBox/SparkleShare in new blog posts. I will also release the application and source code as usual : )

Cheers!

1) http://openassembler.wordpress.com/ – requires Python and PyQt which excludes pure C++ development – this doesn’t suit my needs
2) https://github.com/nical/kiwi – originally written in D (look above); C++ version is pretty much work in progress, and it’s a lot more complicated than QNodesEditor – among other things it imposes conventions intended for nodes-based processing with regards to data containers, ready states, etc. etc. – complicates things unnecessarily IMHO. UPDATE: After taking another look at kiwi I discovered it actually contains a very simple standalone node editor called Qiwi – it’s quite all-right, but doesn’t support port names and saving/loading.
UPDATE: 3) http://nukengine.com/qt-node-editor/ – this one was actually the closest to meet my expectations although I found the necessity to create GUI elements for nodes/ports myself and then attach logical nodes/ports classes to them to be bothersome. It’s a cool project though and I really like it, especially smart connections alignment.

QNodesEditor’s hallmark is being as simple as it gets. Blocks are just blocks, I don’t decide what they should be used for, maybe you just want them to be there and look pretty – it’s your choice. If you want to implement some processing logic – it’s up to you. New types of blocks can even be created completely dynamically in runtime, you don’t have to subclass anything. QNodesEditor is primarily a GUI tool.

Blocks consist of named input and output ports. Ports can have additional flags, currently just NamePort and TypePort (ports that cannot be used for connections, they’re just there to display some extra text with special formatting on the block – yes, you can think of it as an ugly hack). QNodesEditor supports saving and loading of node diagrams. Again – all data are saved as-is (names, connections, positions) without any introspection. It’s up to you to interpret the graphical schematic, attach extra data to it, etc. Blocks and connections are saved in the same order as they’re placed in the QGraphicsScene, so it seems natural to reference them by index when saving your application-specific data.

A short example:

    QGraphicsScene *s = new QGraphicsScene();
    ui->graphicsView->setScene(s);
    ui->graphicsView->setRenderHint(QPainter::Antialiasing);

    QNEBlock *b = new QNEBlock(0, s);
    b->addPort("test", 0, QNEPort::NamePort);
    b->addPort("TestBlock", 0, QNEPort::TypePort);
    b->addInputPort("in1");
    b->addInputPort("in2");
    b->addInputPort("in3");
    b->addOutputPort("out1");
    b->addOutputPort("out2");
    b->addOutputPort("out3");

    b = b->clone();
    b->setPos(150, 0);

    b = b->clone();
    b->setPos(150, 150);

    nodesEditor = new QNodesEditor(this);
    nodesEditor->install(s);

As you can see, it can hardly be any easier to set up a nodes-based editor. After creating a block “template” and cloning it several times to different positions in the scene, you just install QNodesEditor onto QGraphicsScene and voila, your QGraphicsScene is now working as a fully-fledged node editor. Left click and drag on nodes to move them around. Do the same with ports to create connections. Right click nodes and connections to delete them. You can do multiple selection by left-clicking with Ctrl pressed.

If you want to save your diagram, it cannot be any simpler:

QFile f("test.nodes");
f.open(QFile::WriteOnly);
QDataStream ds(&f);
nodesEditor->save(ds);

Want to load them back? No sweat:

QFile f("test.nodes");
f.open(QFile::ReadOnly);
QDataStream ds(&f);
nodesEditor->load(ds);

The code is BSD-licensed. You can use it as-is and develop application-specific stuff completely separately or just modify the code to suit your needs, since it’s really lightweight and easy to understand. Anyway – good luck and enjoy! Don’t forget to drop some feedback in case you find it useful (or not )!

Cheers!

DEMO: qnodeseditor_demo.zip
SOURCE CODE: qnodeseditor_src.zip

% Where I is 1-, 2- or 3-dimensional image
[~, index] = sort(reshape(I, numel(I), 1), 1, ‘descend’);
blobs = ls_blob_detect(I, index);

/* Lindenberg's watershed-based blob detection algorithm implementation for MATLAB
   Author: Stanislaw Adaszewski, 2012 */

#include <mex.h>

static void ind2sub(int nx, int ny, int nz, int idx, int *x, int *y, int *z) {
    int r1 = idx % (nx * ny);
    *z = idx / (nx * ny);
    *y = r1 / nx;
    *x = r1 % nx;
}

static int sub2ind(int nx, int ny, int nz, int x, int y, int z) {
    if (x < 0 || x >= nx || y < 0 || y >= ny || z < 0 || z >= nz)
        return -1;
    else
        return x + nx * (y + ny * z);
}

static const int ofs[][3] = {
    {-1, -1, -1}, {-1,  0, -1}, {-1, 1, -1}, {0, -1, -1}, {0, 0, -1}, {0, 1, -1}, {1, -1, -1}, {1, 0, -1}, {1, 1, -1},
    {-1, -1,  0}, {-1,  0,  0}, {-1, 1,  0}, {0, -1,  0},
            // {0, 0, 0},
    { 0,  1,  0}, { 1, -1,  0}, { 1, 0,  0}, {1,  1,  0},
    {-1, -1,  1}, {-1,  0,  1}, {-1, 1,  1}, {0, -1,  1}, {0, 0,  1}, {0, 1,  1}, {1, -1,  1}, {1, 0,  1}, {1, 1,  1}
};

void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
    if (nlhs != 1 || nrhs != 2 || mxGetNumberOfDimensions(prhs[0]) > 3 || !mxIsDouble(prhs[0]) || mxGetClassID(prhs[1]) != mxINT32_CLASS || mxGetNumberOfElements(prhs[1]) != mxGetNumberOfElements(prhs[0])) {
        mexErrMsgTxt("Usage: R=ls_blob_detect(I, index)\nI must be 1-, 2- or 3-dimensional image\nindex must be list of voxel offsets (0-based) in decreasing brightness order");
        return;
    } else {
        int N = mxGetNumberOfElements(prhs[0]);
        double *data1 = mxGetPr(prhs[0]);
        int n_blobs = 0;
        const mwSize *siz = mxGetDimensions(prhs[0]);
        int ndim = mxGetNumberOfDimensions(prhs[0]);
        mxArray *R = mxCreateNumericArray(ndim, siz, mxINT32_CLASS, mxREAL);
        int nx, ny, nz;
        int *map = (int*) mxGetData(R);
        int *index = (int*) mxGetData(prhs[1]); // malloc(sizeof(int) * N);
        int i;

        if (!R) {
            mexErrMsgTxt("Out of memory.");
            return;
        }

        plhs[0] = R;

        for (i = 0; i < N; i++)
            map[i] = 0;

        nx = siz[0];
        ny = siz[1];
        if (ndim > 2)
            nz = siz[2];
        else
            nz = 1;

        for (i = 0; i < N; i++) {
           int x, y, z;
           int *neighbors = (int*) calloc(sizeof(int), n_blobs+1);
           int j;
           int blob, blob_cnt = 0;
           if (!neighbors) {
               mexErrMsgTxt("Out of memory.");
               return;
           }

           if (data1[index[i]] == 0)
               continue; // Ignore 0 voxels

           ind2sub(nx, ny, nz, index[i], &x, &y, &z);

           for (j = 0; j < 26; j++) {
               int idx_neighbor = sub2ind(nx, ny, nz, x + ofs[j][0], y + ofs[j][1], z + ofs[j][2]);

               if (idx_neighbor == -1)
                   continue; // Ignore voxels outside of volume boundaries

               if (data1[idx_neighbor] > data1[index[i]])
                   neighbors[map[idx_neighbor]] += 1;
           }

           for (j = 0; j < n_blobs; j++)
               if (neighbors[1+j] > 0) {
                   blob_cnt += 1;
                   blob = j;
               }

           if (neighbors[0]>0 || blob_cnt>1) {
                map[index[i]] = 0; // background
           } else if (blob_cnt > 0) {
                map[index[i]] = 1 + blob; // existing blob
           } else {
                n_blobs += 1;
                map[index[i]] = n_blobs; // new blob
           }

           free(neighbors);
        }
    }
}

DOWNLOAD: Flow Field Editor Update 2

Enjoy!

DOWNLOAD: Flow Field Editor Update

And it’s WAY more impressive when animated!

Next, I thought that the way of creating flowmaps I’d described before is a little bit too complicated and so I created a little flow editor in Qt to make preparation of flowmaps more straightforward. You can sketch the flow as you see fit and the rest will be interpolated using Natural Neighbor algorithm. Due to the nature of NN the more flow points you add, the faster it works (recomputation of Voronoi diagram is faster, read NN description if you want to understand). The example flow field takes just a couple of seconds on one 3GHz core.

And this is what it looks like in Unity with little debug info added:

and without debug:

It’s WAY WAY more impressive with animation, you can actually see the water interacting with obstacles. I tried going back to Simple Daylight Water from Unity and it looks like a child’s play now when my water is INTERACTING with the environment. Pretty cool. Thanks Valve (guys from Valve came up with this idea at SIGGRAPH 2010), GraphicsRunner (guy who wrote all about it and prepared a demo in C#) and Alzahiel (guy who prepared the initial port to Unity). I’ve modified Alzahiel’s shader a little bit and now I’m contributing the flow editor. Enjoy!

DOWNLOAD: Flow Editor

PS. You can also try the updated monkey game

DOWNLOAD: Monkey Dodge – Unity Game