Linux for research

Comment in .vimrc

2011-09-19T14:06:00.001-05:00

It is unusual. It is ".

matlab mex

2011-07-31T22:10:00.000-05:00

1. be careful with the data type. It messes up instead of telling you that there is some implicit conversion.

use vi to open two files at the same time.

2011-07-26T20:49:00.005-05:00

from here

Sometimes you need to edit a new or existing file while looking at a separate file using VI. This can be very useful and a powerful time saver. Fortunately you can do this using some simple commands.

First go ahead and edit a file with VI

shellprompt$ vi test-1.txt

while in VI enter the following

:new

This will open a new split screen session, in order to navigate between the two windows in VI do the following

ctr-w
j

ctr-w
k

Using the first will move you to the lower window and using the latter will move you to the upper window.

To make one of the windows full screen and out of the dual screen mode use the following

:only

*Important Side Notes

If you used :new and opened up a new window session it will not have a name so you cannot save it without entering the following

:wq whatevername.txt

Also if you want to open a file in split screen mode that is not new and exists you can enter the following

:new /path/to/whateverfile

list only direcoties

2011-07-16T23:45:00.002-05:00

>> ls -d */

to list hidden direcotories:

>> ls -d .*/

mac: move applications to different spaces.

2011-07-05T21:09:00.000-05:00

You do not have to view all Spaces to move windows between them (That is, by pressing F8, then using your mouse to drag and drop the desired window to the desire Space location). Nor do you have to drag to a screen edge, wait, then drop. If you like to use your keyboard, here's a fast way to do it.

Using your mouse, click and hold the window you want to move to another Space.
While still holding your mouse button down, use your Spaces keyboard shortcut to move to the desired Space. This is usually done by pressing Control and one of the arrow keys.

The window you are holding will be moving with you as you change your Spaces. Once you reach your destination, release the mouse button.

[robg adds: You can also use this method to move the window directly to a numbered space -- just select the window, then press Control-1, -2, -3, etc. This is my preferred method of moving a window to a space, as it seems by far the quickest.]

source from here

rsync exclude files.

2011-05-20T22:29:00.000-05:00

To exclude some directory, check the following:

http://www.thegeekstuff.com/2011/01/rsync-exclude-files-and-folders/

uninstall Qt

2011-05-06T16:08:00.002-05:00

sudo /Developer/Tools/uninstall-qt.py

ITK directory

2011-03-22T13:52:00.000-05:00

To configure cmake
ITK_DIR
It should be "/Users/xxxx/software/InsightToolKitCompiled", where you put your compiled ITK.

Problem with ITK: library not loaded.

2011-03-21T09:14:00.000-05:00

Problem:
dyld: Library not loaded: libITKCommon.3.16.dylib

Solution:
export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:/usr/local/lib/InsightToolkit

/usr/local/lib/InsightToolkit is where the "libITKCommon.3.16.dylib" lives in.

use grep

2010-12-28T09:20:00.000-06:00

Recently I am using Mercurial to manage my Matlab codes. I need combine commands "hg" with "grep" to see which files are updated. Here is how it is working:

>> hg status | grep '\.m$'

The above command will give all the .m files without any other junks, such as "*.m~" and other image files.

Install python packages.

2010-12-23T22:55:00.001-06:00

Python provides a easy solution to install packages and resolve package dependencies.

>> sudo easy_install simplejson

This works very well!!!

Debian Lenny.

2010-11-17T20:00:00.001-06:00

Have not used Linux (Debian) for a while. Today, my old computer for my son showed some problem with X windows. I could not start the X server. Tried to reconfigure the Xorg. The Wiki from Debian is very helpful. Followings are the steps I followed.

Switch to a console as root (not a terminal emulator in X), then run:

/etc/init.d/kdm stop
/etc/init.d/gdm stop
/etc/init.d/xdm stop
cd /etc/X11/
Xorg -configure

Alternatively, reboot the machine in single user mode, then run:

cd /etc/X11/
Xorg -configure

Follow the on-screen instructions. This should give you something to work with.

Run X

After installation run:

startx

apple page customize dictionary

2010-10-11T09:37:00.001-05:00

copied from: http://discussions.apple.com/thread.jspa?threadID=531999

I've converted the all.dic from Medic.zip in the format you need with Pages. A quick test showed that it works.

If you send me your e-mail address, I'll send you the new dictionary file. Click on my name above the atavar and use the e-mail address in the Biography field.

You then only need to join your ~/Library/Spelling/en with the new medic.en:

* Either open both en and medic.en in TextEdit and copy medic.en to the en window, then save the file
Or, if you're familiar with Terminal.all, you could cd to ~/Library/Spelling and use this command:

cat ~/Desktop/medic.en >> en

(I assume that you unzipped the file to your desktop)
---

If you want to change all.dic by yourself, then you have to replace the line endings with a special character from the en file. The character looks like "^@" but is in fact one character. In the resulting file, the words are all in one line separated by the special character. TextEdit doesn't show this character, so to change all.dic you should use something like emacs that comes with Mac OS X. You can launch emacs in Terminal.app.

vi editor: multiline comment

2010-09-22T05:48:00.003-05:00

1. :x,y s/^/# /

The colon is command mode, obviously
x and y is a range of line numbers you want to affect
s is a sed substitution, the caret (^) means the beginning of the line
The sharp (#) is the comment character, again obviously
I put a space after the comment, but it isn't necessary, substitute any string that suits you.

2. Another way to do do this is to visually select the lines you want to comment with shift-v and up and down arrows, then type

:s/^/# /

Easier for blocks of fewer lines.

NB: When you press : vim will add '<,'> to the command line so the final command is:

:'<,'>s/^/# /

Vim: comment multiple lines

2010-09-20T14:10:00.001-05:00

Vim Tip: Comment out multiple lines

Posted on June 13, 2007 by Mark| 25 Comments

Commenting out a bunch of lines without a vim plugin:

Select your lines with VISUAL BLOCK (CTRL-V), then press I to insert before all highlighted lines. Next type your comment character, # (for python, shell, etc). Last press ESC.

I forget not frequently used, but helpful VIM commands from time to time. Why not blog it?

You can alternatively select your lines with VISUAL LINE (SHIFT-V), then type : s/^/#
This tells the selected lines that you wish to substitute the start of the line with the # char.

vim cut past; copy and past

2010-09-20T13:42:00.001-05:00

Ever try to cut (or copy) some lines and paste to another place? If you need to count the lines first, then try these to eliminate counting task.

Cut and Paste:
1. Place the cursor at the beginning of the block you want to CUT.
2. Mark it with md
3. Go to the end of the block.
4. Cut it with d'd
5. Go to the new location that you want to PASTE those text.
Press P.

Copy and Paste:
1. Place the cursor at the beginning of the block you want to COPY.
2. Mark it with my
3. Go to the end of the block.
4. Copy it with y'y
5. Go to the new location that you want to PASTE those text.
Press P.

The name of the mark used is related to the operation (d:delete or y:yank).
I found that those mark names requires minimal movement of my finger.

Visual line mode (by shift+v):
delete by: d
Visual block mode (by ctrl + v):
delete by: c

Cool vi

2010-08-12T19:44:00.002-05:00

Start to vi as my editor on Mac. It is very cool. Here I just record some of the very useful notes for myself.

1. show line numbers
:set number
one can hide the numbers by :set nonumber

Sharing Data Among a GUI's Callbacks

2010-05-12T13:58:00.000-05:00

http://www.mathworks.com/access/helpdesk/help/techdoc/creating_guis/f13-998449.html

The first method, nested functions, seems to work only when you write the GUI programmatically. If you use GUIDE, this may not be easy to implement. In such case, use application data is better.

compile Qt from source code.

2010-05-02T21:56:00.000-05:00

Decided to compile from source because I want to have -arch x86_64 -cocoa and -qt-tiff

This target is using the GNU C++ compiler (macx-g++).

   Recent versions of this compiler automatically include code for
   exceptions, which increase both the size of the Qt libraries and
   the amount of memory taken by your applications.

   You may choose to re-run configure with the -no-exceptions
   option to compile Qt without exceptions. This is completely binary
   compatible, and existing applications will continue to work.

Build type: macx-g++
Architecture: macosx ( x86_64 )
Using framework: Cocoa

Build ............... libs tools examples demos docs translations
Configuration ....... build_all debug shared dll largefile stl precompile_header mmx 3dnow sse sse2 x86_64 absolute_library_soname minimal-config small-config medium-config large-config full-config dwarf2 qt3support phonon phonon-backend accessibility opengl reduce_exports ipv6 getaddrinfo ipv6ifname getifaddrs png gif no-freetype system-zlib nis cups openssl xmlpatterns multimedia audio-backend svg webkit script scripttools release debug qt_framework x86_64
Debug ............... yes (combined)
Default Link ........ debug
Qt 3 compatibility .. yes
QtDBus module ....... no
QtConcurrent code.... yes
QtScript module ..... yes
QtScriptTools module yes
QtXmlPatterns module yes
Phonon module ....... yes
Multimedia module ... yes
SVG module .......... yes
WebKit module ....... yes
JavaScriptCore JIT .. To be decided by JavaScriptCore
Declarative module .. no
STL support ......... yes
PCH support ......... yes
MMX/3DNOW/SSE/SSE2.. yes/yes/yes/yes
Graphics System ..... default
IPv6 support ........ yes
IPv6 ifname support . yes
getaddrinfo support . yes
getifaddrs support .. yes
Accessibility ....... yes
NIS support ......... yes
CUPS support ........ yes
Iconv support ....... no
Glib support ........ auto
GStreamer support ... auto
Large File support .. yes
GIF support ......... yes
TIFF support ........ plugin (qt)
JPEG support ........ plugin (qt)
PNG support ......... yes (qt)
MNG support ......... plugin (qt)
zlib support ........ system
Session management .. auto
OpenGL support ...... yes (Desktop OpenGL)
OpenVG support ...... no
ODBC support ........ plugin
SQLite support ...... plugin (qt)
OpenSSL support ..... yes (run-time)
alsa support ........ no

lipo in Mac

2010-05-02T21:07:00.000-05:00

lipo is very helpful. Look at the following examples.

$ lipo -info /usr/local/lib/libgd.a
input file /usr/local/lib/libgd.a is not a fat file
Non-fat file: /usr/local/lib/libgd.a is architecture: ppc7400

$ lipo -info /usr/lib/libcrypto.dylib
Architectures in the fat file: /usr/lib/libcrypto.dylib are: ppc7400 ppc64 i386 x86_64

How to uninstall Qt on Mac.

2010-05-02T20:43:00.000-05:00

If you installed the binary file, do the following:

sudo /Developer/Tools/uninstall-qt.py

Use dar to backup large directories to multiple DVDs.

2010-04-22T15:27:00.001-05:00

I have a large directory of research data. Cannot use tar to do the work because the file size limit of tar is 4G. Finally get dar, which works very well. Use the following to backup

>> sudo dar -s 10M -c test -R / -g /Volumes/DATABACKUP/Research/ -v

The above means: backup all the stuffs in directory /Volumes/DATABACKUP/Research/. Since there are so many files in this directory, dar will make sure that the files it generate is small enough for later use. Here with -s 10M, dar generates files of 10 M. -v is used to display message. -R is used to set the ROOT directory, which is / here. -g restricts the directory to /Volumes/DATABACKUP/Research/.

Doxygen graph interpretation.

2010-04-15T22:13:00.000-05:00

call graph:

A ------> B: A is called by B.

Classes:

A ----> B: Actually B is the parent class! One way to understand/remember this that A is called as B (for example: A is a dog class; B is an animal class. Dog is called as animal.

Qt and gsl library problem.

2010-04-07T00:01:00.000-05:00

ld: warning: in /usr/local/lib/libgsl.dylib, file is not of required architecture

Solution:

open the Makefile and:

1. CFLAGS: get rid of "arch i386'.

2. CXXFLAGS: get rid of "arch i386"

3. comment LFLAGS.

4. QMAKE_COMP_QMAKE_OBJECTIVE_CFLAGS: get rid of "arch i386".

then save the Makefile and do:

> make clean

> make

you will get warning but it should pass!

dyld: Library not loaded

2010-04-06T20:57:00.000-05:00

After I installed qwt, everything seems to work. However, whenever I execute the program (examples), I got into trouble. When I used Qt creator to open one particular example and build it, I encountered the following error:
dyld: Library not loaded: libqwt.5.dylib
I searched the internet and did not find any easy solution. Proudly I used the following command to fix the problem. It may not be elegant but it works for me.

sudo ln -s /usr/local/qwt-5.2.0/lib/libqwt.5.dylib /usr/lib/libqwt.5.dylib

logout kde desktop from command line.

2010-03-29T20:11:00.000-05:00

1. 'killall kdeinit' to logout KDE. 2. 'dcop kdesktop default logout'. This one will popout the logout dialog and ask the user what to do (logout, cancel or reboot). 3. 'dcop ksmserver ksmserver logout 0 0 0 '. If you want to reboot the machine after logout you have 'dcop ksmserver ksmserver logout 0 1 1'

kde slow keyboard response

2010-03-29T19:35:00.000-05:00

Check the following solution.

Fortunately you can turn it off with just the mouse by going to the K menu; Control Centre -> Regional and Accessibility -> Accessibility -> Activation Gestures, and untick the first box ('Use gestures for activating slow keys and sticky keys'). Also go to the Keyboard Filters tab and untick the 'Use slow keys' box if it is ticked. Press apply and you should be OK.

switch to root user from kde GUI "run command".

2010-03-29T19:21:00.002-05:00

Use:

kdesu command

lock kde screen from command line.

2010-03-29T19:20:00.002-05:00

Lock your KDE screen from the command line

January 29th, 2009 by T4L

Did you know you can lock your current KDE screen by using the command line? For the 3.x series use

dcop kdesktop KScreensaverIface lock

and for KDE 4.x try

qdbus org.freedesktop.ScreenSaver /ScreenSaver Lock

With the help of these you should be able to craft a simple shell script that will lock your screen at given actions. For example, you can leave your screen unlocked and make the PC activate the commands above when it detects mouse movement or when a certain application is launched.

Top 10 things that annoy programmer

2010-03-22T21:19:00.003-05:00

Copied from http://www.kevinwilliampang.com/2008/08/28/top-10-things-that-annoy-programmers/

Very nice post!

Top 10 Things That Annoy Programmers

Written by Kevin Pang on August 28, 2008 — 125 Comments

Programmers all have their pet peeves. Whether it’s scope creep, Hungarian notation, or smelly coworkers, we’ve come to accept that there are certain nuisances that come with our line of work. The following is a list of the top 10 things that annoy programmers, compiled from the results ofmy recent question on StackOverflow along with some of my own experiences:

10. Comments that explain the “how” but not the “why”

Introductory-level programming courses teach students to comment early and comment often. The idea is that it’s better to have too many comments than to have too few. Unfortunately, many programmers seem to take this as a personal challenge to comment every single line of code. This is why you will often see something like this code snippit taken from Jeff Atwood’s post on Coding Without Comments:

1r = n / 2; // Set r to n divided by 2
2
3// Loop while r - (n/r) is greater than t
4while ( abs( r - (n/r) ) > t ) {
5    r = 0.5 * ( r + (n/r) ); // Set r to half of r + (n/r)
6}

Do you have any idea what this code does? Me neither. The problem is that while there are plenty of comments describing what the code is doing, there are none describing why it’s doing it.

Now, consider the same code with a different commenting methodology:

1// square root of n with Newton-Raphson approximation
2r = n / 2;
3
4while ( abs( r - (n/r) ) > t ) {
5    r = 0.5 * ( r + (n/r) );
6}

Much better! We still might not understand exactly what’s going on here, but at least we have a starting point.

Comments are supposed to help the reader understand the code, not the syntax. It’s a fair assumption that the reader has a basic understanding of how a for loop works; there’s no need to add comments such as “// iterate over a list of customers”. What the reader is not going to be familiar with is why your code works and why you chose to write it the way you did.

9. Interruptions

Very few programmers can go from 0 to code at the drop of a hat. In general, we tend to be more akin to locomotives than ferraris; it may take us awhile to get started, but once we hit our stride we can get an impressive amount of work done. Unfortunately, it’s very hard to get into a programming zone when your train of thought is constantly being derailed by clients, managers, and fellow programmers.

There is simply too much information we need to keep in mind while we’re working on a task to be able to drop the task, handle another issue, then pick up the task without missing a beat. Interruptions kill our train of thought and getting it back is often a time-consuming, frustrating, and worst of all, error-prone process.

8. Scope creep

From Wikipedia:

Scope creep (also called focus creep, requirement creep, feature creep, and sometimes kitchen sink syndrome) in project management refers to uncontrolled changes in a project’s scope. This phenomenon can occur when the scope of a project is not properly defined, documented, or controlled. It is generally considered a negative occurrence that is to be avoided.

Scope creep turns relatively simple requests into horribly complex and time consuming monsters. It only takes a few innocent keystrokes by the requirements guy for scope creep to happen:

Version 1: Show a map of the location
Version 2: Show a 3D map of the location
Version 3: Show a 3D map of the location that the user can fly through

Argh! What used to be a 30 minute task just turned into a massively complex system that could take hundreds of man hours. Even worse, most of the time scope creep happens during development, which requires rewriting, refactoring, and sometimes throwing out code that was developed just days prior.

7. Management that doesn’t understand programming

Ok, so maybe there are some perks.

Management is not an easy job. People suck; we’re fickle and fragile and we’re all out for #1. Keeping a large group of us content and cohesive is a mountain of a task. However, that doesn’t mean that managers should be able to get away without having some basic understanding of what their subordinates are doing. When management cannot grasp the basic concepts of our jobs, we end up with scope creep, unrealistic deadlines, and general frustration on both sides of the table. This is a pretty common complaint amongst programmers and the source of a lot of angst (as well as one hilarious cartoon).

6. Documenting our applications

Let me preface this by saying that yes, I know that there are a lot of documentation-generating applications out there, but in my experience those are usually only good for generating API documentation for other programmers to read. If you are working with an application that normal everyday people are using, you’re going to have to write some documentation that the average layman can understand (e.g. how your application works, troubleshooting guides, etc.).

It’s not hard to see that this is something programmers dread doing. Take a quick look at all the open-source projects out there. What’s the one thing that all of them are constantly asking for help with? Documentation.

I think I can safely speak on behalf of all programmers everywhere when I say, “can’t someone else do it?“.

5. Applications without documentation

I never said that we weren’t hypocrites. Programmers are constantly asked to incorporate 3rd party libraries and applications into their work. In order to do that, we need documentation. Unfortunately, as mentioned in item 6, programmers hate writing documentation. No, the irony is not lost on us.

There is nothing more frustrating than trying to utilize a 3rd party library while having absolutely no fricken idea what half the functions in the API do. What’s the difference between poorlyNamedFunctionA() and poorlyButSimilarlyNamedFunctionB()? Do I need to perform a null check before accessing PropertyX? I guess I’ll just have to find out through trial and error! Ugh.

4. Hardware

Any programmer who has ever been called upon to debug a strange crash on the database server or why the RAID drives aren’t working properly knows that hardware problems are a pain. There seems to be a common misconception that since programmers work with computers, we must know how to fix them. Granted, this may be true for some programmers, but I reckon the vast majority of us don’t know or really care about what’s going on after the code gets translated into assembly. We just want the stuff to work like it’s supposed to so we can focus on higher level tasks.

3. Vagueness

“The website is broken”. “Feature X isn’t working properly”. Vague requests are a pain to deal with. It’s always surprising to me how exasperated non-programmers tend to get when they are asked to reproduce a problem for a programmer. They don’t seem to understand that “it’s broken, fix it!” is not enough information for us to work off of.

Software is (for the most part) deterministic. We like it that way. Humor us by letting us figure out which step of the process is broken instead of asking us to simply “fix it”.

2. Other programmers

Programmers don’t always get along with other programmers. Shocking, but true. This could easily be its own top 10 list, so I’m just going to list some of the common traits programmers have that annoy their fellow programmers and save going into detail for a separate post:

Being grumpy to the point of being hostile.
Failing to understand that there is a time to debate system architecture and a time to get things done.
Inability to communicate effectively and confusing terminology.
Failure to pull ones own weight.
Being apathetic towards the code base and project

And last, but not least, the number 1 thing that annoys programmers…

1. Their own code, 6 months later

Don’t sneeze, I think I see a bug.

Ever look back at some of your old code and grimace in pain? How stupid you were! How could you, who know so much now, have written that? Burn it! Burn it with fire!

Well, good news. You’re not alone.

The truth is, the programming world is one that is constantly changing. What we regard as a best practice today can be obsolete tomorrow. It’s simply not possible to write perfect code because the standards upon which our code is judged is evolving every day. It’s tough to cope with the fact that your work, as beautiful as it may be now, is probably going to be ridiculed later. It’s frustrating because no matter how much research we do into the latest and greatest tools, designs, frameworks, and best practices, there’s always the sense that what we’re truly after is slightly out of reach. For me, this is the most annoying thing about being a programmer. The fragility of what we do is necessary to facilitate improvement, but I can’t help feeling like I’m one of those sand-painting monks.

Well, there you have it. The top 10 things that annoy programmers. Again, if you feel that I missed anything please be sure to let me know in the comments!

locales in debian system.

2010-03-19T19:51:00.000-05:00

Configuring Locales

The Easy Way

Install debconf (i.e. run apt-get update then apt-get install debconf, as root)
Run dpkg-reconfigure locales as root

problem with iwork: keynote quit unexpectedly while using the SFWordProcessing plugin

2010-01-09T20:08:00.001-06:00

Solution is here

Symptoms

After updating to Mac OS X v10.6.2, iWeb and iWork applications may quit unexpectedly. On my computer it shows the following:
"keynote quit unexpectedly while using the SFWordProcessing plugin"

Products Affected

Numbers '09, Keynote '09, iWork '09, iWeb '09

Resolution

This issue may be resolved by removing the font database. To do this:

Important: If you use Font Book to manage your fonts, you will need to open Font Book after step 3. Font Book library information will be restored. However, the state of whether fonts are active or disabled will be lost. You will need to correct this manually.

Shut down your computer.
Start up your computer while holding down the Shift key. This starts your computer in Safe Mode and removes the font database.
Restart your computer.
Open the application that quit unexpectedly (iWeb, Keynote, Pages, or Numbers).

Building And Using Static And Shared "C" Libraries

2009-12-23T11:24:00.003-06:00

(Original location: http://users.actcom.co.il/~choo/lupg/tutorials/libraries/unix-c-libraries.html)

Table Of Contents:

Building And Using Static And Shared "C" Libraries
What Is A "C" Library? What Is It Good For?
Creating A Static "C" Library Using "ar" and "ranlib"
Using A "C" Library In A Program
Creating A Shared "C" Library Using "ld"
Using A Shared "C" Library - Quirks And Solutions
Using A Shared "C" Library Dynamically - Programming Interface
1. Loading A Shared Library Using dlopen()
2. Calling Functions Dynamically Using dlsym()
3. Unloading A Shared Library Using dlclose()
4. Automatic Startup And Cleanup Functions
Getting a Deeper Understanding - The Complete Linking Story
1. The Importance Of Linking Order
2. Static Linking Vs. Dynamic Linking

Building And Using Static And Shared "C" Libraries

One of the problems with developed programs, is that they tend to grow larger and larger, bringing up overall compilation and linking time to a large figure, and polluting out makefile, and the directory where we placed the source files. The first time a program we write reaches this state, is normally when we look for a different way to manage our projects.
It is this point where we start thinking about combining out source code into small units of related files, that can be managed with a separate makefile, possibly by a different programmer (for a multi-programmer project).

What Is A "C" Library? What Is It Good For?

One of the tools that compilers supply us with are libraries. A library is a file containing several object files, that can be used as a single entity in a linking phase of a program. Normally the library is indexed, so it is easy to find symbols (functions, variables and so on) in them. For this reason, linking a program whose object files are ordered in libraries is faster than linking a program whose object files are separate on the disk. Also, when using a library, we have fewer files to look for and open, which even further speeds up linking.
Unix systems (as well as most other modern systems) allow us to create and use two kinds of libraries - static libraries and shared (or dynamic) libraries.
Static libraries are just collections of object files that are linked into the program during the linking phase of compilation, and are not relevant during runtime. This last comment seems obvious, as we already know that object files are also used only during the linking phase, and are not required during runtime - only the program's executable file is needed in order to run the program.
Shared libraries (also called dynamic libraries) are linked into the program in two stages. First, during compile time, the linker verifies that all the symbols (again, functions, variables and the like) required by the program, are either linked into the program, or in one of its shared libraries. However, the object files from the dynamic library are not inserted into the executable file. Instead, when the program is started, a program in the system (called a dynamic loader) checks out which shared libraries were linked with the program, loads them to memory, and attaches them to the copy of the program in memory.
The complex phase of dynamic loading makes launching the program slightly slower, but this is a very insignificant drawback, that is out-weighted by a great advantage - if a second program linked with the same shared library is executed, it can use the same copy of the shared library, thus saving a lot of memory. For example, the standard "C" library is normally a shared library, and is used by all C programs. Yet, only one copy of the library is stored in memory at any given time. This means we can use far less memory to run our programs, and the executable files are much smaller, thus saving a lot of disk space as well.
However, there is one drawback to this arrangement. If we re-compile the dynamic library and try to run a second copy of our program with the new library, we'll soon get stuck - the dynamic loader will find that a copy of the library is already stored in memory, and thus will attach it to our program, and not load the new (modified) version from disk. There are ways around this too, as we'll see in the last section of our discussion.

Creating A Static "C" Library Using "ar" and "ranlib"

The basic tool used to create static libraries is a program called 'ar', for 'archiver'. This program can be used to create static libraries (which are actually archive files), modify object files in the static library, list the names of object files in the library, and so on. In order to create a static library, we can use a command like this:

ar rc libutil.a util_file.o util_net.o util_math.o

This command creates a static library named 'libutil.a' and puts copies of the object files "util_file.o", "util_net.o" and "util_math.o" in it. If the library file already exists, it has the object files added to it, or replaced, if they are newer than those inside the library. The 'c' flag tells ar to create the library if it doesn't already exist. The 'r' flag tells it to replace older object files in the library, with the new object files.
After an archive is created, or modified, there is a need to index it. This index is later used by the compiler to speed up symbol-lookup inside the library, and to make sure that the order of the symbols in the library won't matter during compilation (this will be better understood when we take a deeper look at the link process at the end of this tutorial). The command used to create or update the index is called 'ranlib', and is invoked as follows:

ranlib libutil.a

On some systems, the archiver (which is not always ar) already takes care of the index, so ranlib is not needed (for example, when Sun's C compiler creates an archive, it is already indexed). However, because 'ar' and 'ranlib' are used by many makefiles for many packages, such platforms tend to supply a ranlib command that does nothing. This helps using the same makefile on both types of platforms.
Note: when an archive file's index generation date (stored inside the archive file) is older than the file's last modification date (stored in the file system), a compiler trying to use this library will complain its index is out of date, and abort. There are two ways to overcome the problem:

Use 'ranlib' to re-generate the index.
When copying the archive file to another location, use 'cp -p', instead of only 'cp'. The '-p' flag tells 'cp' to keep all attributes of the file, including its access permissions, owner (if "cp" is invoked by a superuser) and its last modification date. This will cause the compiler to think the index inside the file is still updated. This method is useful for makefiles that need to copy the library to another directory for some reason.

Using A "C" Library In A Program

After we created our archive, we want to use it in a program. This is done by adding the library's name to the list of object file names given to the linker, using a special flag, normally '-l'. Here is an example:

cc main.o -L. -lutil -o prog

This will create a program using object file "main.o", and any symbols it requires from the "util" static library. Note that we omitted the "lib" prefix and the ".a" suffix when mentioning the library on the link command. The linker attaches these parts back to the name of the library to create a name of a file to look for. Note also the usage of the '-L' flag - this flag tells the linker that libraries might be found in the given directory ('.', refering to the current directory), in addition to the standard locations where the compiler looks for system libraries.
For an example of program that uses a static library, try looking at our static library example directory.

Creating A Shared "C" Library Using "ld"

The creation of a shared library is rather similar to the creation of a static library. Compile a list of object files, then insert them all into a shared library file. However, there are two major differences:

Compile for "Position Independent Code" (PIC) - When the object files are generated, we have no idea where in memory they will be inserted in a program that will use them. Many different programs may use the same library, and each load it into a different memory in address. Thus, we need that all jump calls ("goto", in assembly speak) and subroutine calls will use relative addresses, and not absolute addresses. Thus, we need to use a compiler flag that will cause this type of code to be generated.
In most compilers, this is done by specifying '-fPIC' or '-fpic' on the compilation command.
Library File Creation - unlike a static library, a shared library is not an archive file. It has a format that is specific to the architecture for which it is being created. Thus, we need to use the compiler (either the compiler's driver, or its linker) to generate the library, and tell it that it should create a shared library, not a final program file.
This is done by using the '-G' flag with some compilers, or the '-shared' flag with other compilers.

Thus, the set of commands we will use to create a shared library, would be something like this:


cc -fPIC -c util_file.c
cc -fPIC -c util_net.c
cc -fPIC -c util_math.c
cc -shared libutil.so util_file.o util_net.o util_math.o

The first three commands compile the source files with the PIC option, so they will be suitable for use in a shared library (they may still be used in a program directly, even thought they were compiled with PIC). The last command asks the compiler to generate a shared library

Using A Shared "C" Library - Quirks And Solutions

Using a shared library is done in two steps:

Compile Time - here we need to tell the linker to scan the shared library while building the executable program, so it will be convinced that no symbols are missing. It will not really take the object files from the shared library and insert them into the program.
Run Time - when we run the program, we need to tell the system's dynamic loader (the process in charge of automatically loading and linking shared libraries into the running process) where to find our shared library.

The compilation part is easy. It is done almost the same as when linking with static libraries:

cc main.o -L. -lutil -o prog

The linker will look for the file 'libutil.so' (-lutil) in the current directory (-L.), and link it to the program, but will not place its object files inside the resulting executable file, 'prog'.
The run-time part is a little trickier. Normally, the system's dynamic loader looks for shared libraries in some system specified directories (such as /lib, /usr/lib, /usr/X11/lib and so on). When we build a new shared library that is not part of the system, we can use the 'LD_LIBRARY_PATH' environment variable to tell the dynamic loader to look in other directories. The way to do that depends on the type of shell we use ('tcsh' and 'csh', versus 'sh', 'bash', 'ksh' and similar shells), as well as on whether or not 'LD_LIBRARY_PATH' is already defined. To check if you have this variable defined, try:

echo $LD_LIBRARY_PATH

If you get a message such as 'LD_LIBRARY_PATH: Undefined variable.', then it is not defined.
Here is how to define this variable, in all four cases:

'tcsh' or 'csh', LD_LIBRARY_PATH is not defined:


    setenv LD_LIBRARY_PATH /full/path/to/library/directory

'tcsh' or 'csh', LD_LIBRARY_PATH already defined:


    setenv LD_LIBRARY_PATH /full/path/to/library/directory:${LD_LIBRARY_PATH}

'sh', 'bash' and similar, LD_LIBRARY_PATH is not defined:


    LD_LIBRARY_PATH=/full/path/to/library/directory
    export LD_LIBRARY_PATH

'sh', 'bash' and similar, LD_LIBRARY_PATH already defined:


    LD_LIBRARY_PATH=/full/path/to/library/directory:${LD_LIBRARY_PATH}
    export LD_LIBRARY_PATH

After you've defined LD_LIBRARY_PATH, you can check if the system locates the library properly for a given program linked with this library:

ldd prog

You will get a few lines, each listing a library name on the left, and a full path to the library on the right. If a library is not found in any of the system default directories, or the directories mentioned in 'LD_LIBRARY_PATH', you will get a 'library not found' message. In such a case, verify that you properly defined the path to the directory inside 'LD_LIBRARY_PATH', and fix it, if necessary. If all goes well, you can run your program now like running any other program, and see it role...
For an example of a program that uses a shared library, try looking at our shared library example directory.

Using A Shared "C" Library Dynamically - Programming Interface

One of the less-commonly used feature of shared libraries is the ability to link them to a process anytime during its life. The linking method we showed earlier makes the shared library automatically loaded by the dynamic loader of the system. Yet, it is possible to make a linking operation at any other time, using the 'dl' library. This library provides us with a means to load a shared library, reference any of its symbols, call any of its functions, and finally detach it from the process when no longer needed.
Here is a scenario where this might be appealing: suppose that we wrote an application that needs to be able to read files created by different word processors. Normally, our program might need to be able to read tens of different file formats, but in a single run, it is likely that only one or two such document formats will be needed. We could write one shared library for each such format, all having the same interface (readfile and writefile for example), and one piece of code that determines the file format. Thus, when our program is asked to open such a file, it will first determine its format, then load the relevant shared library that can read and translate that format, and call its readfile function to read the document. We might have tens of such libraries, but only one of them will be placed in memory at any given time, making our application use less system resources. It will also allow us to ship the application with a small set of supported file formats, and add new file formats without the need to replace the whole application, by simply sending the client an additional set of shared libraries.

Loading A Shared Library Using `dlopen()`

In order to open and load the shared library, one should use the dlopen() function. It is used this way:


#include       /* defines dlopen(), etc.       */
.
.
void* lib_handle;       /* handle of the opened library */

lib_handle = dlopen("/full/path/to/library", RTLD_LAZY);
if (!lib_handle) {
    fprintf(stderr, "Error during dlopen(): %s\n", dlerror());
    exit(1);
}

The dlopen() function gets two parameters. One is the full path to the shared library. The other is a flag defining whether all symbols refered to by the library need to be checked immediatly, or only when used. In our case, we may use the lazy approach (RTLD_LAZY) of checking only when used. The function returns a pointer to the loaded library, that may later be used to reference symbols in the library. It will return NULL in case an error occured. In that case, we may use the dlerror() function to print out a human-readable error message, as we did here.

Calling Functions Dynamically Using `dlsym()`

After we have a handle to a loaded shared library, we can find symbols in it, of both functions and variables. We need to define their types properly, and we need to make sure we made no mistakes. The compiler won't be able to check those declarations, so we should be extra carefull when typing them. Here is how to find the address of a function named 'readfile' that gets one string parameter, and returns a pointer to a 'struct local_file' structure:


/* first define a function pointer variable to hold the function's address */
struct local_file* (*readfile)(const char* file_path);
/* then define a pointer to a possible error string */
const char* error_msg;
/* finally, define a pointer to the returned file */
struct local_file* a_file;

/* now locate the 'readfile' function in the library */
readfile = dlsym(lib_handle, "readfile");

/* check that no error occured */
error_msg = dlerror();
if (error_msg) {
    fprintf(stderr, "Error locating 'readfile' - %s\n", error_msg);
    exit(1);
}

/* finally, call the function, with a given file path */
a_file = (*readfile)("hello.txt");

As you can see, errors might occur anywhere along the code, so we should be carefull to make extensive error checking. Surely, you'll also check that 'a_file' is not NULL, after you call your function.

Unloading A Shared Library Using `dlclose()`

The final step is to close down the library, to free the memory it occupies. This should only be done if we are not intending to use it soon. If we do - it is better to leave it open, since library loading takes time. To close down the library, we use something like this:

dlclose(lib_handle);

This will free down all resources taken by the library (in particular, the memory its executable code takes up).

Automatic Startup And Cleanup Functions

Finally, the dynamic loading library gives us the option of defining two special functions in each library, namely _init and _fini. The _init function, if found, is invoked automatically when the library is opened, and before dlopen() returns. It may be used to invoke some startup code needed to initialize data structures used by the library, read configuration files, and so on.
The _fini function is called when the library is closed using dlclose(). It may be used to make cleanup operations required by the library (freeing data structures, closing files, etc.).
For an example of a program that uses the 'dl' interface, try looking at our dynamic-shared library example directory.

Getting a Deeper Understanding - The Complete Linking Story

The Importance Of Linking Order

In order to fully understand the way linking is done, and be able to overcome linking problems, we should bare in mind that the order in which we present the object files and the libraries to the linker, is the order in which the linker links them into the resulting binary file.
The linker checks each file in turn. If it is an object file, it is being placed fully into the executable file. If it is a library, the linker checks to see if any symbols referenced (i.e. used) in the previous object files but not defined (i.e. contained) in them, are in the library. If such a symbol is found, the whole object file from the library that contains the symbol - is being added to the executable file. This process continues until all object files and libraries on the command line were processed.
This process means that if library 'A' uses symbols in library 'B', then library 'A' has to appear on the link command before library 'B'. Otherwise, symbols might be missing - the linker never turns back to libraries it has already processed. If library 'B' also uses symbols found in library 'A' - then the only way to assure successful linking is to mention library 'A' on the link command again after library 'B', like this:

$(LD) ....... -lA -lB -lA

This means that linking will be slower (library 'A' will be processed twice). This also hints that one should try not to have such mutual dependencies between two libraries. If you have such dependencies - then either re-design your libraries' contents, or combine the two libraries into one larger library.
Note that object files found on the command line are always fully included in the executable file, so the order of mentioning them does not really matter. Thus, a good rule is to always mention the libraries after all object files.

Static Linking Vs. Dynamic Linking

When we discussed static libraries we said that the linker will try to look for a file named 'libutil.a'. We lied. Before looking for such a file, it will look for a file named 'libutil.so' - as a shared library. Only if it cannot find a shared library, will it look for 'libutil.a' as a static library. Thus, if we have created two copies of the library, one static and one shared, the shared will be preferred. This can be overridden using some linker flags ('-Wl,static' with some linkers, '-Bstatic' with other types of linkers. refer to the compiler's or the linker's manual for info about these flags).

[LUPG Home] [Tutorials] [Related Material] [Essays] [Project Ideas] [Send Comments]

This document is copyright (c) 1998-2002 by guy keren.

The material in this document is provided AS IS, without any expressed or implied warranty, or claim of fitness for a particular purpose. Neither the author nor any contributers shell be liable for any damages incured directly or indirectly by using the material contained in this document.

permission to copy this document (electronically or on paper, for personal or organization internal use) or publish it on-line is hereby granted, provided that the document is copied as-is, this copyright notice is preserved, and a link to the original document is written in the document's body, or in the page linking to the copy of this document.

Permission to make translations of this document is also granted, under these terms - assuming the translation preserves the meaning of the text, the copyright notice is preserved as-is, and a link to the original document is written in the document's body, or in the page linking to the copy of this document.

For any questions about the document and its license, please contact the author.

QString and number format.

2009-12-14T08:46:00.002-06:00

Question: how to construct 0001.tif, 0002.tif, ..... and 0010.tif using QString?

With C++, one can use sprintf to do this. sprintf(str, '%04d', i) where str is the output string, i is the iteration number (from 1 to 10). With QString, one can also use sprintf, but as the document mentions it is not the recommended way. Instead, using arg is better.

Here is one example showing how to use arg to construct number format.

#include <_QtCore/QCoreApplication>
#include <_QString>
#include <_QDebug>

int main(int argc, char *argv[])
{
   QCoreApplication a(argc, argv);
   uint d = 90;
   QString test("9 is %1");
   const QChar fillChar = QLatin1Char('0');
   QString testNew = test.arg(d, 5, 10, fillChar);
   qDebug() << "string is: " << testNew;

   return a.exec();
}

the output is:

string is: "9 is 00090"

ffmpeg usage.

2009-10-21T09:38:00.000-05:00

Using ffmpeg to make movies is much faster than using ImageJ. The followings are the commonly used commands:

>> ffmpeg -r 60 -i %d.jpg -sameq -s vga out.mp4

-r 60 means the frame rate of the movie is 60;
-i %d.jpg: inputs are jpg sequences.
-sameq: make sure that the movie frames are the same quality as the input sequential images.
-s vga: constrains the size of the frames to vga size, which is 640x480.

compile Qt4.6 on snow leopard.

2009-10-18T11:05:00.001-05:00

I had trouble with the binary files, both 4.5 and 4.6Beta. The installer freezes at "validating packages". Finally I decided to compile the source files. The first trial failed with a lot of errors related with tiff files. Then I used the following command and successfully compiled the file.

>> ./configure -qt-libtiff -sdk

>> make

>> sudo make install

So far it seems to work well.

binutils on snow leopard

2009-10-15T22:29:00.000-05:00

use the following when config:

>> ./configure --disable-werror

otherwise it won't work.

compile openCV 2.0 on snow leopard

2009-10-15T14:04:00.002-05:00

In the command window:

>> CXXFLAGS="-m32"
>> LDFLAGS="-m32"
>> ./configure

After that, do the following:

>> make
>> sudo make install (run as root).

enable root account in Mac (10.6)

2009-10-15T13:11:00.003-05:00

The easiest way to enable root is to start a terminal session, and type:

sudo passwd root

You will be prompted for a new password to enable root access.

If it does not work, following next steps:

Open the Directory Utility located in /System/Library/CoreServices/.
Unlock the application by clicking the padlock icon and entering your Administrator login.
From the Edit menu, select Enable Root User.
Chose Change Root Password from the Edit menu and chose a password for the root user.

That’s it! Make sure to lock the application by clicking the padlock icon.

QLabel

2009-10-12T00:38:00.001-05:00

when set the qlabel pixmap, use the following:

ui->label->setPixmap(QPixmap::fromImage(image));

QPixmap::fromImage is a static function.

The following codes do not seem to work:

QPixmap pixmap;

pixmap.fromImage(image);

ui->label->setPixmap(pixmap);

How to Build Up a Bulleted List in Apple Keynote ’09

2009-10-07T21:37:00.001-05:00

http://www.ehow.com/how_4929870_build-up-bulleted-list-keynote.html

"arguments too long" error

2009-09-30T16:11:00.001-05:00

http://en.wikipedia.org/wiki/Xargs

Use xargs to deal with "arguments too long" error.

use python to manipulate large number of files in a directory.

2009-09-29T22:01:00.000-05:00

When you have tons of files in a folder and want to manipulate them together, you will have trouble. For example if you use "mv" or "cp", you will get "Arguments are too long". You can use python to do this.

here is how to do it.

invoke python first.

>>> import os, glob, shutil
>>> for file in glob.glob('./directory1/*.tif'):
shutil.copy(file, './temp')

this should work.

debian (5.0) install more languages.

2009-09-17T05:52:00.002-05:00

as root

>> dpkg-reconfigure locales

Use the above to install more locales.

Image processing libraries!

2009-09-14T14:06:00.002-05:00

PL，IPP，openCV，ITK，VTK，visDSK（转）

2009-03-02 09:18

IPL---INTEL 图象处理库免费源代码不公开
openCV--INTEL 图象处理库免费源代码公开
IPP--IPP--INTEL 集成开发环境库（图象处理、信号处理等）收费源代码不公开
visDSK---MICROSOFT 图象处理库免费源代码公开

ITK(Insight Segmentation and Registration ToolKit)提供了一个医学图像分割与配准的算法平台,它源于美国的可视人体项目(The Visual Human Project)[3]。同样地,ITK也支持跨平台开发,以开放源代码的形式发布,目前其稳定版本为1.6,提供了几乎所有主流的医学图像分割与配准算法。

VTK(The Visualization Toolkit)是美国Kitware公司的一个开放源码的自由软件(open source)。可以应用于图像处理、计算机图形学和科学计算可视化。它在科学计算可视化尤其是三维重建功能如面绘制和体绘制方面具有强大的功能,使其在可视化,尤其是在医学图像领域得到广泛应用。VTK完全采用面向对象的设计思想来设计与开发,提供了超过300个C++类,支持Window,Unix与Linux等多种平台,支持C,C++,Java,Tcl/Tk以及Python等编程语言,目前已发布的稳定版本是4.2。

Advanced Digital Imaging Solutions Laboratory (ADISL)
Image Apprentice is a C/C++ based Image Processing Learner’s Toolkit. Students use it as a companion to their favourite Image Processing Textbook. It allows one to use self-written image processing algorithms as plugins.
It comes with a Plugin Development Kit (PDK) that has a skeleton code having a simple coding style. A student who has attended a 101-level course in C/C++ programming is well-equipped to write an Image Processing plugin for Image Apprentice using Visual C++.

AllSeeingI
AllSeeingI (ASI) is the codename for a computer vision and visualization framework. It is a visual programming environment for rapid development and easy reusability.

Editor's Note - This project is just getting started but may be a chance for developers to contribute to a brand new vision system.

CamCap and CLAG
Links to the Nottingham video processing environment otherwise known collectively as CamCap, for camera and video processing work and CLAG, for command line based image processing/display and prototyping. The environment is windows based and makes use of DirectShow and the intel open source computer vision library (OpenCV).

CImg
The CImg Library is an open source C++ toolkit for image processing. It provides simple classes and functions to load, save, process and display images in your own C++ code. CImg stands for "Cool Image" : It is simple to use and efficient. It's like a STL for image processing!

CMVision
Project goal was to create a simple, robust vision system suitable for real time robotics applications. The system aims to perform global low level color vision at video rates without the use of special purpose harware.

CVIPtools
One of the primary purposes of the CVIPtools development is to allow students, faculty, and other researchers to explore the power of computer processing of digital images.
The newest version of CVIPtools, version 4.3, developed at the Computer Vision and Image Processing Laboratory at Southern Illinois University at Edwardsville, under the continuing direction of Dr. Scott E Umbaugh is currently available with the new textbook, Computer Imaging: Digital Image Analysis and Processing.

EDISON
Code for the Edge Detection and Image SegmentatiON system. This system is a low-level feature extraction tool that integrates confidence based edge detection and mean shift based image segmentation. It was developed by the Robust Image Understanding Laboratory at Rutgers University.

FILTERS
Filters is a library (not an application) implementing image filters and image processing functions.

Gandalf
The Fast Computer Vision and Numerical Library. Gandalf is a C library designed to support the development of computer vision applications. Gwyddion
Gwyddion is a modular program for SPM (scanning probe microscopy) data analysis. Primarily it is supposed to be used for analysis of height fields obtained by means of scanning probe microscopy techniques (AFM, MFM, STM, NSOM), but generally it can be used for any other height field analysis or image analysis.

Gluas plus GIMP - GNU Image Manipulation Program
Gluas is a GIMP plug-in providing a enviroment for testing algorithms for image processing. The environment contains a simple editor for entering the algorithms. It uses the lua interpreter.

Hornets Eye
HornetsEye also is an attempt to trim down the Mimas library and create a minimalistic and consistent C++/Ruby real-time computer vision library with an interface to Ruby.

iLab Neuromorphic Vision C++ Toolkit (iNVT)
The iLab Neuromorphic Vision C++ Toolkit is a comprehensive set of C++ classes for the development of neuromorphic models of vision. Neuromorphic models are computational neuroscience algorithms whose architecture and function is closely inspired from biological brains. The iLab Neuromorphic Vision C++ Toolkit comprises not only base classes for images, neurons, and brain areas, but also fully-developed models such as our model of bottom-up visual attention and of Bayesian surprise.

IM Toolkit
Windows and UNIX - The idea behind IM was to create a toolkit that was not so complex as OpenCV, neither so big as VTK, but that can be used as a solid base to the development of thesis and dissertations, as for commercial applications.

ImageJ
ImageJ is a public domain Java image processing program inspired by NIH Image for the Macintosh. It runs, either as an online applet or as a downloadable application, on any computer with a Java 1.1 or later virtual machine. Downloadable distributions are available for Windows, Mac OS, Mac OS X and Linux.

Editor's Note - This project is geared towards medical image analysis. If you need to analyze image cross-sections, break/create image stacks, then this package is worth some attention!

ImLib3D
ImLib3D is a C++ library and visualisation system for 3D image processing. It contains most basic image processing algorithms, and some more sophisticated ones. ImLib3D images are STL-compliant templated containers.

Imalab
Imalab is a powerful development environment for complex applications in computer vision. It allows for flexible interactive experimentation with the vision modules developed in the Prima team, and can be dynamically extended with new modules. A versatile scripting mechanism provides for fast and convenient interactive development.

Editor's Note - Most of the documentation is in French.

IMLAB
IMLAB is a free open source graphical application for Scientific Image Processing that runs in Windows, Linux and many other UNIX systems. It supports multiple windows, data types including 32 bit integers, 32 bit real numbers and complex numbers. It is implemented in C++ and also in C to provide a very simple way to add new functions. It has many image operations and supports several file formats.

IPL
Intel® Integrated Performance Primitives (Intel® IPP) is a software library of highly optimized functions for multimedia, audio, video, speech, computer vision, image and signal processing.

IMPROMPTU
IMPROMPTU, which stands for IMage PROcessing Module for the Prototyping, Testing, and Utilization of image analysis processes, is a software package for multi-dimensional image processing. With IMPROMPTU, a user can construct an arbitrary sequence of operations to run automatically on an input volume. This sequence, referred to as a process, can be made up of operations selected from any of several categories. Each category, which represents one general type of image-processing operation, contains a number of functions.

JHLabs
Jerry's Java Image Processing Pages. A great way to explore many image processing filters by experimenting with Java applets.
Java Advanced Imaging (JAI) API
The Java Advanced Imaging API provides a set of object-oriented interfaces that support a simple, high-level programming model which lets you manipulate images easily.

MegaWave
MegaWave2 is a free software intended for image processing. It is made of a C library of modules, that contains original algorithms written by researchers and a Unix/Linux package designed for the fast developpement of new image processing algorithms.

Leptonica Library
This site contains well-tested C code for some basic image processing operations, along with a description of the functions and some design methods. A full set of affine transformations (translation, shear, rotation, scaling) on images of all depths is included, with the exception that some of the scaling methods do not work at all depths. There are also implementations of binary morphology, grayscale morphology, convolution and rank order filters, and applications such as jbig2 image processing and color quantization.

LTI-Lib
The LTI-Lib is an object oriented library with algorithms and data structures frequently used in image processing and computer vision. It has been developed at the Chair of Technical Computer Science (Lehrstuhl fuer Technische Informatik) LTI at the Aachen University of Technology, as part of many research projects in computer vision dealing with robotics, object recognition and sign language and gesture recognition.

Lispix
Lispix is a public domain image analysis program for Microsoft Windows (PC), written and maintained by David Bright. It features a collection of special purpose research tools for electron microscopy and spectral imaging at NIST. Most of Lispix is written in Common Lisp.

LuaMat
LuaMat aims to provide a easy to use language to create visual effects and to modify images. LuaMat is a fast way to use the most popular algorithms of Image Processing and Computer Vision. As Lua, becoming the standard for video-game scripting engines, LuaMat is fast and has a simple syntax.

The Mimas toolkit
Mimas was originally conceived as a platform for real-time machine vision research. Its aim was and still is to reduce the turnaround time of new research into the application workspace. It is written in C++ and is released in source code form subject to the GNU Lesser General Public License (LGPL).

Mavis
Mavis is computer vision software for mobile robots. It's part of an ongoing, group robotics project, called Leaf.

MIRIAD
MIRIAD (Multichannel Image Reconstruction, Image Analysis and Display) is a toolbox, in the form of an environment with a large set of moderate-sized program which perform individual tasks, involving calibration, mapping, deconvolution and image analysis of interferometric data. MIRIAD software is also part of the Hat Creek telescope control software; data obtained from the telescopes is directly written into MIRIAD format with a MIRIAD user interface.

Motion
Motion is a program that monitors the video signal from one or more cameras and is able to detect if a significant part of the picture has changed; in other words, it can detect motion.

tnimage
tnimage is a scientific image analysis program that allows you to create, edit, analyze, and produce color prints of images. It is particularly useful for analyzing images of SDS and agarose gels and X-ray or MRI images.

NeatVision
NeatVision is a free Java based image analysis and software development environment, which provides high level access to a wide range of image processing algorithms through well defined and easy to use graphical interface. NeatVision is in its second major release.

NIH IMAGE
NIH Image is a public domain image processing and analysis program for the Macintosh. It was developed at the Research Services Branch (RSB) of the National Institute of Mental Health (NIMH), part of the National Institutes of Health (NIH).

Editor's Note - The NIH IMAGE project is similar to ImageJ. In fact they are documented side by side. ImageJ is recommended to be used by PC based users as NIH IMAGE is a Mac based program.

OpenCV
OpenCV is an extensive open-source image processing library, built on the Intel Image Processing Library (IPL). OpenCV aids commercial uses of computer vision in human-computer interface, robotics, monitoring, biometrics and security by providing a free and open infrastructure where the distributed efforts of the vision community can be consolidated and performance optimized.

Peter Kovesi Research
MATLAB and Octave Functions for Computer Vision and Image Processing.

Projective Vision Toolkit
The Projective Vision Toolkit (PVT) is a series of utilities that allows one to take an image sequence and compute the fundamental matrix and trilinear tensor.
This can be used for such problems as camera selfcalibration, structure from motion, camera motion annotation, image stabilization, 3D tracking and recognition, etc.

RAVL - Recognition And Vision Library
RAVL provides a base C++ class library, together with a range of computer vision, pattern recognition and supporting tools. The aim of RAVL is to move software developed within the Centre for Vision, Speech and Signal Processing at the University of Surrey, England for research purposes into the public domain and to support its use in a wider community.

RoboRealm
Using RoboRealm you can create a low cost vision software solution with a standard webcam that allows you to explore the very complex world of image analysis and image processing. Through an easy to use analysis pipeline you can add image processing filters to translate an image into robotic movements, computer actions, or just plain fun! RoboRealm is free to download!

RobotVisionCAD
RobotVisionCAD or in short RvCAD is a computer aided design for Image Processing and Computer Vision. RvCAD's GUI presents users with a view where users drag and drop Image Processor Elements, and visually connecting them to form Image Processing Pipeline. RvCAD supports real-time live video processing from VideoForWindow, DirectShow(WDM) and Video4Linux on linux, compatible capture device.

SPIDER
SPIDER (System for Processing Image Data from Electron microscopy and Related fields) is an image processing system for electron microscopy.

TINA
TINA (TINA Is No Acronym) is an open source environment developed to accelerate the process of image analysis research. TINA provides functionality to assist in all areas of image analysis including handling of image, image feature and geometrical data; statistical and numerical analysis of data; GUI development as well as transmission and containment of data. TINA also provides a range of high-level analysis techniques for both machine vision (3D object location, 2D object recognition, temporal-stereo depth estimation, etc) and medical image analysis (MR tissue segmentation, blood flow analysis, etc).

Tekkotsu
Exploring Tekkotsu Programming on the Sony AIBO. Tekkotsu (see www.Tekkotsu.org) is an application development framework for the Sony AIBO robot dog. ("Tekkotsu" literally means iron bones in Japanese, and refers to a metal framework, such as the skeleton of a building.) At its lowest level, Tekkotsu provides primitives for sensory processing, smooth control of effectors, and event-based communication.

Torch3vision
It's a machine vision library, written in simple C++ and based on the Torch machine-learning library. This package contains Basic image processing and feature extraction algorithms such as rotation, flip, photometric normalizations (Histogram Equalization, Multiscale Retinex, Self-Quotient Image or Gross-Brajovic), edge detection, 2D DCT, 2D FFT, 2D Gabor, PCA to do Eigen-Faces, LDA to do Fisher-Faces

UTHSCSA ImageTool
UTHSCSA ImageTool (IT) is a free image processing and analysis program for Microsoft Windows 9x, Windows ME or Windows NT. IT can acquire, display, edit, analyze, process, compress, save and print gray scale and color images.IT can read and write over 22 common file formats including BMP, PCX, TIF, GIF and JPEG.

VXL
VXL (the Vision-something-Libraries) is a collection of C++ libraries designed for computer vision research and implementation. It was created from TargetJr and the IUE with the aim of making a light, fast and consistent system. VXL is written in ANSI/ISO C++ and is designed to be portable over many platforms. There are libraries covering numerical algorithms, image processing, co-ordinate systems, camera geometry, stereo, video manipulation, structure recovery from motion, probability modelling, GUI design, classification, robust estimation, feature tracking, topology, structure manipulation, 3d imaging, and much more.

XMegaWave
XMegaWave (XMW) is a freeware graphical windows environment oriented towards image processing. The development of XMW has been based on the collaboration between researchers from the University of the Balearic Islands (Spain), the University of Las Palmas de Gran Canaria (Spain) and the University of Paris IX Dauphine (France).

XVision
XVision provides an application independent set of tools for visual feature tracking optimized to be simple to configure at the user level, yet extremely fast to execute.

Matlab memory management.

2009-09-11T10:45:00.001-05:00

Here is the office site describing how to use memory efficiently with Matlab.
One common pit is the following:

>> a=rand(100e6,1);

The above command will generate vector a; now if you want to generate another set of random numbers and store in a, you may think you just type in:

>> a = rand(100e6, 1)

This will not work!!!

You need to do the following:
>> a = rand(100e6, 1);
>> clear;
>> a= rand(100e6, 1);

This way, basically you clear out the old variable "a" first, then you generate a new one and store it in a. Basically the biggest memory to use to allocate the variable is half of your memory in this case.

Mac keynote 2009 format.

2009-09-09T14:28:00.000-05:00

he new iWork '09 suite includes a new file format that packs all the data into a single file, rather than using a package bundle, as did iWork '08.

To get the folder, just change the extension of the file from .key to .zip. Then you can just unzip it to a folder. Change back from .zip to .key will give you the intact keynote file.

To get the old formats back, simply go into Preferences in each iWork application, and under the General tab, check the box that says Save new documents as packages.

Tricks to search emails in gmail.

2009-05-18T19:49:00.002-05:00

To search all the unread emails:

In the search box, type "is:unread" without quotes. It will show you all the unread emails. By using "is:unread label:inbox", you will get all the unread emails in the inbox.

delete locked files on Mac

2009-04-15T15:25:00.000-05:00

Advanced tip about deleting locked files

If there are several locked files in the Trash, you can unlock them all at the same time at the command line. Follow these steps:

Open Terminal. It's located in /Applications/Utilities.

Type: chflags -R nouchg Note: Type one space (not pictured) after nouchg in the line above, so that it ends in "nouchg ". Do not press Return yet.
Double-click the Trash icon in the Dock to reveal the contents of the Trash. If necessary, arrange the Finder window so that a portion of the Terminal window is still visible.
Press the Command-A key combination to select all files in the Trash.
Drag the files from the Trash to the Terminal window.
Note: This automatically enters the pathname for each file. This eliminates the need to individually empty multiple Trash directories, particularly when multiple disks or volumes are present.
Press Return. No special text message will be shown indicating that the command was successful.
Empty the Trash.

If the Trash does not empty or if you see a message in Terminal that says "usage: chflags [-R [-H | -L | -P]] flags file..." you most likely did not type the text in step 2 as indicated or did not leave a space. Repeat the steps if this happens.

originally from: http://support.apple.com/kb/HT1526

Qt link error

2009-01-09T21:53:00.001-06:00

I install Qt (4.4.3) version of dmg files and debug files (dmg file) the instalation is full. I type

qmake -project (create project.pro)
qmake (create project.xcodeproj)

I open xcodeproj file in xcode (version 2.2.1) and copile project. The stage of compiler is good but the stage of linking send me this error:

/usr/bin/ld: /Library/Frameworks/QtGui.framework/QtGui load command 6 unknown cmd field

/usr/bin/ld: /Library/Frameworks/QtCore.framework/QtCore load command 5 unknown cmd field

collect2: ld returned 1 exit status
---------------------------------------------------------------------------------------------------------
I solved this problem by upgrading my xcode to version 2.5. Now the program can be compiled.

Recover old version of Qt on Mac (Tiger)

2009-01-05T19:11:00.001-06:00

I have problems with Qt 4.4 on my Mac (tiger) and I posted my questions. But so far no real solution yet. I want to switch back to Qt 4.3.4. But when I used the dmg file to install it, the computer says "there is nothing to install". How can I deal with this?

Navigate to /Library/Receipts, find the Reciept from the last time you used the package installer to install 4.3.4 (back before you had 4.4.0), and delete it/them. Looking at my machine, it looks like there might be several packages named something like Qt_libraries, Qt_docs, etc. The installer should be happy then. No guarantees as to how well this will actually work with the 4.4.0 install though. I THINK it should work.

Mac and ldconfig

2008-12-30T15:48:00.001-06:00

In Mac system, there is NO ldconfig which exists in Linux system. The corresponding command in Mac is called "dyld". You can find out more details by "man dyld"

Switch between gdm and kdm

2008-12-18T20:01:00.003-06:00

First make sure that you installed gdm and kdm. Then use the following command in a console.

>> sudo dpkg-reconfigure gdm

From the dialog choose either gdm or kdm.

C++ Virtual function

2008-09-21T13:35:00.003-05:00

Purpose

The concept of the virtual function solves the following problem:

In OOP when a derived class inherits from a base class, an object of the derived class may be referred to (or cast) as either being the base class type or the derived class type. If there are base class functions overridden by the derived class, a problem then arises when a derived object has been cast as the base class type. When a derived object is referred to as being of the base's type, the desired function call behavior is ambiguous.

The distinction between virtual and not virtual resolves this ambiguity. If the function in question is designated "virtual" in the base class then the derived class's function would be called (if it exists). If it is not virtual, the base class's function would be called.

Virtual functions overcome the problems with the type-field solution by allowing the programmer to declare functions in a base class that can be redefined in each derived class.

Example

For example, a base class Animal could have a virtual function eat. Subclass Fish would implement eat() differently than subclass Wolf, but you can invoke eat() on any class instance referred to as Animal, and get the eat() behavior of the specific subclass.

This allows a programmer to process a list of objects of class Animal, telling each in turn to eat (by calling eat()), with no knowledge of what kind of animal may be in the list. You also do not need to have knowledge of how each animal eats, or what the complete set of possible animal types might be.

The following is an example in C++:

#include 
using namespace std;

class Animal
{
public:
  virtual void eat() { cout << "I eat like a generic Animal." << class="br0">}
};

class Wolf : public Animal
{
public:
  void eat() { cout << "I eat like a wolf!" << class="br0">}
};

class Fish : public Animal
{
public:
  void eat() { cout << "I eat like a fish!" << class="br0">}
};

class GoldFish : public Fish
{
public:
  void eat() { cout << "I eat like a goldfish!" << class="br0">}
};


class OtherAnimal : public Animal
{
};

int main()
{
  Animal* anAnimal[5];

  anAnimal[0] = new Animal();
  anAnimal[1] = new Wolf();
  anAnimal[2] = new Fish();
  anAnimal[3] = new GoldFish();
  anAnimal[4] = new OtherAnimal();

  for (int i = 0; i < 5; i++) {
     anAnimal[i]->eat();
     delete anAnimal[i];
 }

  return 0;
}

Output with the virtual method Animal::eat():

I eat like a generic Animal.
I eat like a wolf!
I eat like a fish!
I eat like a goldfish!
I eat like a generic Animal.

Output if Animal::eat() were not declared as virtual:

I eat like a generic Animal.
I eat like a generic Animal.
I eat like a generic Animal.
I eat like a generic Animal.
I eat like a generic Animal.

Pure virtual function and virtual function
from here

Finally, we arrive at the end of our long journey through inheritance! This is the last topic we will cover on the subject. So congratulations in advance on making it through the hardest part of the language!

Pure virtual (abstract) functions and abstract base classes

So far, all of the virtual functions we have written have a body (a definition). However, C++ allows you to create a special kind of virtual function called a pure virtual function (or abstract function) that has no body at all! A pure virtual function simply acts as a placeholder that is meant to be redefined by derived classes.

To create a pure virtual function, rather than define a body for the function, we simply assign the function the value 0.

view plain copy to clipboard print ?

class Base
{
public:
const char* SayHi() { return "Hi"; } // a normal non-virtual function
virtual const char* GetName() { return "Base"; } // a normal virtual function
virtual int GetValue() = 0; // a pure virtual function
};

class Base { public: const char* SayHi() { return "Hi"; } // a normal non-virtual function virtual const char* GetName() { return "Base"; } // a normal virtual function virtual int GetValue() = 0; // a pure virtual function };

When we add a pure virtual function to our class, we are effectively saying, “it is up to the derived classes to implement this function”.

Using a pure virtual function has two main consequences: First, any class with one or more virtual functions becomes an abstract base class, which means that it can not be instantiated! Consider what would happen if we could create an instance of Base:

view plain copy to clipboard print ?

int main()
{
Base cBase; // pretend this was legal
cBase.GetValue(); // what would this do?
}

int main() { Base cBase; // pretend this was legal cBase.GetValue(); // what would this do? }

Second, any derived class must define a body for this function, or that derived class will be considered an abstract base class as well.

Let’s take a look at an example of a pure virtual function in action. In a previous lesson, we wrote a simple Animal base class and derived a Cat and a Dog class from it. Here’s the code as we left it:

view plain copy to clipboard print ?

#include
class Animal
{
protected:
std::string m_strName;
// We're making this constructor protected because
// we don't want people creating Animal objects directly,
// but we still want derived classes to be able to use it.
Animal(std::string strName)
: m_strName(strName)
{
}
public:
std::string GetName() { return m_strName; }
virtual const char* Speak() { return "???"; }
};
class Cat: public Animal
{
public:
Cat(std::string strName)
: Animal(strName)
{
}
virtual const char* Speak() { return "Meow"; }
};
class Dog: public Animal
{
public:
Dog(std::string strName)
: Animal(strName)
{
}
virtual const char* Speak() { return "Woof"; }
};

#include class Animal { protected: std::string m_strName; // We're making this constructor protected because // we don't want people creating Animal objects directly, // but we still want derived classes to be able to use it. Animal(std::string strName) : m_strName(strName) { } public: std::string GetName() { return m_strName; } virtual const char* Speak() { return "???"; } }; class Cat: public Animal { public: Cat(std::string strName) : Animal(strName) { } virtual const char* Speak() { return "Meow"; } }; class Dog: public Animal { public: Dog(std::string strName) : Animal(strName) { } virtual const char* Speak() { return "Woof"; } };

We’ve prevented people from allocating objects of type Animal by making the constructor protected. However, there’s one problem that has not been addressed. It is still possible to create derived classes that do not redefine Speak(). For example:

view plain copy to clipboard print ?

class Cow: public Animal
{
public:
Cow(std::string strName)
: Animal(strName)
{
}
// We forgot to redefine Speak
};
int main()
{
Cow cCow("Betsy");
cout << class="string">" says " <<>
}

class Cow: public Animal { public: Cow(std::string strName) : Animal(strName) { } // We forgot to redefine Speak }; int main() { Cow cCow("Betsy"); cout <<>This will print:

Betsy says ???

What happened? We forgot to redefine Speak, so cCow.Speak() resolved to Animal.Speak(), which isn’t what we wanted.

A better solution to this problem is to use a pure virtual function:

view plain copy to clipboard print ?

#include
class Animal
{
protected:
std::string m_strName;
public:
Animal(std::string strName)
: m_strName(strName)
{
}
std::string GetName() { return m_strName; }
virtual const char* Speak() = 0; // pure virtual function
};

#include class Animal { protected: std::string m_strName; public: Animal(std::string strName) : m_strName(strName) { } std::string GetName() { return m_strName; } virtual const char* Speak() = 0; // pure virtual function };

There are a couple of things to note here. First, Speak() is now a pure virtual function. This means Animal is an abstract base class, and can not be instantiated. Consequently, we do not need to make the constructor protected any longer (though it doesn’t hurt). Second, because our Cow class was derived from Animal, but we did not define Cow::Speak(), Cow is also an abstract base class. Now when we try to compile this code:

view plain copy to clipboard print ?

class Cow: public Animal
{
public:
Cow(std::string strName)
: Animal(strName)
{
}
// We forgot to redefine Speak
};
int main()
{
Cow cCow("Betsy");
cout << class="string">" says " <<>
}

class Cow: public Animal { public: Cow(std::string strName) : Animal(strName) { } // We forgot to redefine Speak }; int main() { Cow cCow("Betsy"); cout <<>The compiler will give us a warning because Cow is an abstract base class and we can not create instances of abstract base classes:

C:\\Test.cpp(141) : error C2259: 'Cow' : cannot instantiate abstract class due to following members: C:\Test.cpp(128) : see declaration of 'Cow' C:\\Test.cpp(141) : warning C4259: 'const char *__thiscall Animal::Speak(void)' : pure virtual function was not defined

This tells us that we will only be able to instantiate Cow if Cow provides a body for Speak().

Let’s go ahead and do that:

view plain copy to clipboard print ?

class Cow: public Animal
{
public:
Cow(std::string strName)
: Animal(strName)
{
}
virtual const char* Speak() { return "Moo"; }
};
int main()
{
Cow cCow("Betsy");
cout << class="string">" says " <<>
}

class Cow: public Animal { public: Cow(std::string strName) : Animal(strName) { } virtual const char* Speak() { return "Moo"; } }; int main() { Cow cCow("Betsy"); cout <<>Now this program will compile and print:

Betsy says Moo

A pure virtual function is useful when we have a function that we want to put in the base class, but only the derived classes know what it should return. A pure virtual function makes it so the base class can not be instantiated, and the derived classes are forced to define these function before they can be instantiated. This helps ensure the derived classes do not forget to redefine functions that the base class was expecting them to.

Interface classes

An interface class is a class that has no members variables, and where all of the functions are pure virtual! In other words, the class is purely a definition, and has no actual implementation. Interfaces are useful when you want to define the functionality that derived classes must implement, but leave the details of how the derived class implements that functionality entirely up to the derived class.

Interface classes are often named beginning with an I. Here’s a sample interface class:

view plain copy to clipboard print ?

class IErrorLog
{
virtual bool OpenLog(const char *strFilename) = 0;
virtual bool CloseLog() = 0;
virtual bool WriteError(const char *strErrorMessage) = 0;
};

class IErrorLog { virtual bool OpenLog(const char *strFilename) = 0; virtual bool CloseLog() = 0; virtual bool WriteError(const char *strErrorMessage) = 0; };

Any class inheriting from IErrorLog must provide implementations for all three functions in order to be instantiated. You could derive a class named FileErrorLog, where OpenLog() opens a file on disk, CloseLog() closes it, and WriteError() writes the message to the file. You could derive another class called ScreenErrorLog, where OpenLog() and CloseLog() do nothing, and WriteError() prints the message in a pop-up message box on the screen.

Now, let’s say you need to write some code that uses an error log. If you write your code so it includes FileErrorLog or ScreenErrorLog directly, then you’re effectively stuck using that kind of error log. For example, the following function effectively forces callers of MySqrt() to use a FileErrorLog, which may or may not be what they want.

view plain copy to clipboard print ?

double MySqrt(double dValue, FileErrorLog &cLog)
{
if (dValue <>
{
cLog.WriteError("Tried to take square root of value less than 0");
return 0.0;
}
else
return dValue;
}

double MySqrt(double dValue, FileErrorLog &cLog) { if (dValue <>A much better way to implement this function is to use IErrorLog instead:

view plain copy to clipboard print ?

double MySqrt(double dValue, IErrorLog &cLog)
{
if (dValue <>
{
cLog.WriteError("Tried to take square root of value less than 0");
return 0.0;
}
else
return dValue;
}

double MySqrt(double dValue, IErrorLog &cLog) { if (dValue <>Now the caller can pass in any class that conforms to the IErrorLog interface. If they want the error to go to a file, they can pass in an instance of FileErrorLog. If they want it to go to the screen, they can pass in an instance of ScreenErrorLog. Or if they want to do something you haven’t even thought of, such as sending an email to someone when there’s an error, they can derive a new class from IErrorLog (eg. EmailErrorLog) and use an instance of that! By using IErrorLog, your function becomes more independent and flexible.

Interface classes have become extremely popular because they are easy to use, easy to extend, and easy to maintain. In fact, some modern languages, such as Java and C#, have added an “interface” keyword that allows programmers to directly define an interface class without having to explicitly mark all of the member functions as abstract. Furthermore, although Java and C# will not let you use multiple inheritance on normal classes, they will let you multiply inherit as many interfaces as you like. Because interfaces have no data and no function bodies, they avoid a lot of the traditional problems with multiple inheritance while still providing much of the flexibility.

Using rsync to synchronize the files.

2008-09-21T11:00:00.003-05:00

rsync -autv username@xxx.xxx.xxx.edu:/source_directory/ ./dest_directory

Use "-autv" options. This will make sure that if the files in the dest_directory is newer, it will not be overwritten.
"t" will preserve the time stamp.
"a" archive
"u" update; skip files that are newer on the receiver
"v" print out information

Another thing needs to be careful is that "/" after source_directory is needed if you want to synchronize the files inside source_directory. If "/" is ignored, then source_directory will be copied to dest_directory.

For example: If you have source_directory inside which you have source1, source2 two files. Now you want to synchronize the files with your directory "dest_dir" which at this moment is empty.

> rsync -autv ./source_directory/ ./dest_dir
The above command will copy source1 and source2 to ./dest_dir (since at this moment ./dest_dir is still empty, so the files inside ./source_directory is newer).

What if you want to exclude ./tmp directory?
> rsync -autv --exclude "tmp/" ./source_directory/ ./dest_dir
temp is relative to the directory you are trying to backup, which is ./source_directory/ here.

> rsync -autv ./source_directory ./dest_dir
However, the above command will copy ./source_directory to ./dest_dir. It copy it as a directory. After the command, inside your ./dest_dir you will have another folder called "source_directory".

42 of the Best Free Linux Graphics Software

2008-09-16T07:53:00.000-05:00

42 of the Best Free Linux Graphics Software

The original post is here

Linux is a very strong platform for budding artists, photographers, animators, and designers. With inexpensive hardware, free software, and a modicum of talent and inspiration, anyone can create professional-looking computer graphics.

There is a huge range of Open Source software available to create, modify and convert 2D and 3D computer graphics. To provide an insight into the software that is available, we have compiled a list of 42 high quality Linux graphics applications. The vast majority of the software featured here sports an attractive graphical front-end, although we have not neglected console based applications.

Now, let's explore the 42 graphics applications at hand. For each title we have compiled its own portal page, providing a screenshot of the software in action, a full description with an in-depth analysis of its features, together with links to relevant resources and reviews.

3D Modeling and Rendering
Art of Illusion	3D-modeler, renderer and raytracer
Blender	Very fast and versatile 3D modeler/renderer
K-3D	3D modeling and animation system
Pixie	Photorealistic raytracing renderer for generating photorealistic images
POV-Ray	Full-featured ray tracer
Radiance	Suite of tools for performing lighting simulation
Sunflow	Rendering system for photo-realistic image synthesis
YafRay	Powerful raytracer

Raster Graphics Editor
CinePaint	Painting, manipulation and image processing
GIMP	GNU Image Manipulation Program
Gimpshop	Fork of GIMP mimicing Adobe Photoshop's interface
Krita	Edit and paint images

Vector Graphics Editor
Inkscape	Vector-based drawing program
OpenOffice.org Draw	Produces simple diagrams, flowcharts and 3-D artwork
Xara Xtreme	Heavyweight vector graphics, illustration and DTP program

Animation
Pencil	Create traditional hand-drawn animation using bitmap and vector graphics
Ktoon	Produce professional cartoons
Synfig	Create and edit 2D animations and compositions

Drawing
ArgoUML	UML modelling tool
Dia	Diagram editor
Kivio	Flowcharting program for the KDE Office Suite
Skencil	Interactive vector drawing program

Photo Management
blueMarine	Digital photo manipulation software
F-Spot	Personal photo management application

Viewers
Cornice	Designed to be a free replacement of ACDSee
gThumb	Advanced image viewer and browser
Gwenview	Simple image viewer for KDE 4
Eye of Gnome	Fast and functional image viewer
Imgv	Powerful image viewer

Camera
Cheese	Take pictures and videos from your webcam
digiKam	Digital photo management application for KDE
gphoto2	Set of digital camera software applications
Rawstudio	Raw-image converter and manipulation

Scanning
Kooka	Scanner program for KDE
Tesseract	Optical Character Recognition Engine
XSane	Featureful graphical frontend for SANE

CAD
QCad	Professional CAD System
BRL-CAD	Constructive Solid Geometry (CSG) solid modeling system

Fractals
Gnofract 4D	GNOME based fractal generator
XaoS	Real-time interactive fractal zoomer

Utilities
Agave	Colorscheme designer for the GNOME desktop
ImageMagick	Software suite to create, edit, and compose bitmap images

Linux for research

Comment in .vimrc

matlab mex

use vi to open two files at the same time.

Sometimes you need to edit a new or existing file while looking at a separate file using VI. This can be very useful and a powerful time saver. Fortunately you can do this using some simple commands.

list only direcoties

mac: move applications to different spaces.

rsync exclude files.

uninstall Qt

ITK directory

Problem with ITK: library not loaded.

use grep

Install python packages.

Debian Lenny.

Run X

apple page customize dictionary

vi editor: multiline comment

Vim: comment multiple lines

Vim Tip: Comment out multiple lines

vim cut past; copy and past

Cool vi

Sharing Data Among a GUI's Callbacks

compile Qt from source code.

lipo in Mac

How to uninstall Qt on Mac.

Use dar to backup large directories to multiple DVDs.

Doxygen graph interpretation.

Qt and gsl library problem.

dyld: Library not loaded

logout kde desktop from command line.

kde slow keyboard response

switch to root user from kde GUI "run command".

lock kde screen from command line.

Top 10 things that annoy programmer

Top 10 Things That Annoy Programmers

10. Comments that explain the “how” but not the “why”

9. Interruptions

8. Scope creep

7. Management that doesn’t understand programming

6. Documenting our applications

5. Applications without documentation

4. Hardware

3. Vagueness

2. Other programmers

1. Their own code, 6 months later

locales in debian system.

Configuring Locales

The Easy Way

problem with iwork: keynote quit unexpectedly while using the SFWordProcessing plugin

Symptoms

Products Affected

Resolution

Building And Using Static And Shared "C" Libraries

Building And Using Static And Shared "C" Libraries

What Is A "C" Library? What Is It Good For?

Creating A Static "C" Library Using "ar" and "ranlib"

Using A "C" Library In A Program

Creating A Shared "C" Library Using "ld"

Using A Shared "C" Library - Quirks And Solutions

Using A Shared "C" Library Dynamically - Programming Interface

Loading A Shared Library Using dlopen()

Calling Functions Dynamically Using dlsym()

Unloading A Shared Library Using dlclose()

Automatic Startup And Cleanup Functions

Getting a Deeper Understanding - The Complete Linking Story

The Importance Of Linking Order

Static Linking Vs. Dynamic Linking

QString and number format.

ffmpeg usage.

compile Qt4.6 on snow leopard.

binutils on snow leopard

compile openCV 2.0 on snow leopard

enable root account in Mac (10.6)

QLabel

How to Build Up a Bulleted List in Apple Keynote ’09

"arguments too long" error

use python to manipulate large number of files in a directory.

debian (5.0) install more languages.

Image processing libraries!

Matlab memory management.

Loading A Shared Library Using `dlopen()`

Calling Functions Dynamically Using `dlsym()`

Unloading A Shared Library Using `dlclose()`