The grammer

This is the grammer I have so far:

	textNoStop = Regex('[^\s\{\}\[\]\(\)]+')
	myHtmlComment = QuotedString("<!--",endQuoteChar="-->",multiline=True)
	regularText = (textNoStop ^ Literal("[") ^ Literal("]") ) 

	regularBrackets = Forward()
	regularBrackets << Combine(Literal("(") + ZeroOrMore(Regex('[^\(\)]+') ^ regularBrackets) + Literal(")"))

	link = Forward()
	link << Combine( Literal("[[").suppress() + ZeroOrMore(Regex('[^\[\]]+') ^ link) + Literal("]]").suppress()) 

	curlyShit = Forward()
	curlyShit << Combine( Literal("{{") + ZeroOrMore( Regex('[^\{\}]+') ^ curlyShit ) + Literal("}}") , joinString=" ") 

	curlyCurlyBar = QuotedString("{|",endQuoteChar="|}",multiline=True)+Optional(QuotedString("}",endQuoteChar="|}",multiline=True))
	strangeCurlyBar = QuotedString("|",endQuoteChar="|}",multiline=True) #+NotAny(Literal("}")) # strangely it may also appear like this...
	curlyBar = curlyCurlyBar ^ strangeCurlyBar

	strangeBeginRemark = Combine(Literal(":") + QuotedString("''") , joinString=" ")

	if debug:
		wikiMarkup = OneOrMore(regularText ^ strangeBeginRemark ^ curlyBar ^ curlyShit ^ myHtmlComment ^ link ^ regularBrackets)
	else:
		wikiMarkup = Optional(OneOrMore(regularText.suppress() ^ strangeBeginRemark.suppress() ^ curlyBar.suppress() ^ curlyShit.suppress() ^ myHtmlComment.suppress() ^ link ^ regularBrackets.suppress()))

If you’re not familiar with PyParsing, these are simply rules for each element in the format that I considered relevant.
So first I had to get rid of any “double curly” things in the MediaWiki format (MWf), and they can be nested which stikes out using the simple QuotedString method. I had to build a recursive grammer:

	curlyShit = Forward()
	curlyShit << Combine( Literal("{{") + ZeroOrMore( Regex('[^\{\}]+') ^ curlyShit ) + Literal("}}") , joinString=" ")

As you can see I wasn’t so happy with it…
Anyway, first I have to make an empty declaration of the double-curly, so I can use it recursively, and then work it into the grammer. It basically looking for an opening ‘{{‘ and won’t stop looking inside it until it hits a ‘{‘ (or a ‘}’), then allows for another possible double-curly, and just keeps going until the end. It works.

The rules for the other nested things in the MWf are implemented the same way.

All done?

Alright, everything seems fine and dandy. Well they are not, because Wikipedia is a cesspool of errors in the format, such as this value: http://en.wikipedia.org/wiki/Fianna_Fail (keep in mind it might be updated and fixed by the time you read this)
Which has an un-balanced parenthesis:

'''Fianna Fáil – The Republican Party''' ({{lang-ga|Fianna Fáil – An Páirtí Poblachtánach}}), more commonly known as '''Fianna Fáil''' ({{IPA-ga|ˌfʲiənə ˈfɔːlʲ}} is a [[political party]] in the [[Republic of Ireland]],

It’s right after the IPA double-curly.

And, since my grammer works well for balanced and correctly formatted documents – it fails on this document.

There are more anomalis in the format like this (from http://en.wikipedia.org/wiki/Fredrich_Wilhelm_I_of_Prussia):

{{Refimprove|date=December 2009}}
{|align=right
|{{Infobox royalty|monarch
| name           = Frederick William I
| title          =King in Russia; Elector of Brandenburg
| image          =Friedrich Wilhelm I 1713.jpg
....

| death_place =[[Berlin]], [[Kingdom of Prussia|Prussia]]
| place of burial=[[Sanssouci]], [[Potsdam]]
| religion         =[[Calvinism]]
|}}
|-
|{{House of Hohenzollern (Prussia)|frederickwilliam1}}
|}

While it may seem OK, it’s really parser’s hell… See that opening “{|”? that’s cool but then comes the closing “|}}”, which also matches for the real closer “|}”, that only appears later…

There are more anomalis like that, it’s a whole mess.

Results

Anyway, looking at the big picture I was able to parse ~99.9% of the articles, which is fine by me. Only Wikipedia is ~10,000,000 articles (incl. redirects and disambigs), so I know I’m missing a lot.

So, here’s a result:
Original: Machine

{{About|devices that perform tasks|other uses|Machine (disambiguation)}}
A '''machine''' manages power to accomplish a task, examples include, a [[mechanical system]], a [[computer|computing system]], an [[electronic system]], a [[molecular machine]] and a [[biological machine]]. In common usage, the meaning is that of a device having parts that perform or assist in performing any type of [[Work (physics)|work]]. A [[simple machine]] is a device that transforms the direction or magnitude of a [[force]].

Links found after parsing

['mechanical system', 'computer|computing system', 'electronic system', 'molecular machine', 'biological machine', 'Work (physics)|work', 'simple machine', 'force']

Another one:
Original: Agrippina the elder

{{Infobox royalty
| name        = Agrippina the Elder
| image       = Agripina Maior (M.A.N. Madrid) 01.jpg
| caption     = Agrippina, wife of Germanicus
| imgw        = 200px
| spouse      = [[Germanicus]]
| issue       = [[Nero (son of Germanicus)|Nero Caesar]]<br>[[Drusus Caesar]]<br>[[Caligula]], Roman Emperor<br>[[Agrippina the Younger]], Roman Empress<br>[[Drusilla (sister of Caligula)|Julia Drusilla]]<br>[[Julia Livilla]]
| father      = [[Marcus Vipsanius Agrippa]]
| mother      = [[Julia the Elder]]
| birth_date   = 14 BC
| birth_place  = [[Athens]], [[Greece]]
| death_date   = 18 October 33 (aged 47)
| death_place  = [[Ventotene|Pandataria]]
| place of burial = [[Ventotene|Pandataria]], later the <br>[[Mausoleum of Augustus]]
}}

'''Vipsania Agrippina''' or most commonly known as '''Agrippina Major''' or '''Agrippina the Elder''' (''Major'' Latin for ''the elder'', [[Classical Latin]]: <small>AGRIPPINAGERMANICI</small>,<ref>{{Aut|E. Groag, A. Stein, L. Petersen - e.a.}} (edd.), ''Prosopographia Imperii Romani saeculi I, II et III'' ('''[[PIR]]'''), Berlin, 1933 - V 463</ref> 14 BC  [[18 October]] [[33]]) was a distinguished and prominent granddaughter of the Emperor Augustus. Agrippina was the wife of the general, statesman [[Germanicus]] and a relative to the first [[Roman Emperors]]. She was the second granddaughter of the Emperor [[Augustus]], sister-in-law, stepdaughter and daughter-in-law of the Emperor [[Tiberius]], mother of the Emperor [[Caligula]], maternal second cousin and sister-in-law of the Emperor [[Claudius]] and the maternal grandmother of the Emperor [[Nero]].

Links found:

['Germanicus', 'Roman Emperors', 'Augustus', 'Tiberius', 'Caligula', 'Claudius', 'Nero']

See it handled all the curlys with grace.

So, code is up:

svn checkout http://morethantechnical.googlecode.com/svn/trunk/simpleWikiParser/simpleWiki.py

Enjoy,
Roy.

I had. Until recently, I’d accept this as it was from above, but that was until I discovered this website called UnderGet.

The trick is pretty simple. The engine behind this site works by renaming the file or encoding its content so the blocking software cannot detect it.

I am now able to download my favorite podcast mp3 files when I’m at my workplace

Just wanted to share a thing I made – a simple 2D hand pose estimator, using a skeleton model fitting. Basically there has been a crap load of work on hand pose estimation, but I was inspired by this ancient work. The problem is setting out to find a good solution, and everything is very hard to understand and implement. In such cases I like to be inspired by a method, and just set out with my own implementation. This way, I understand whats going on, simplify it, and share it with you!

Anyway, let’s get down to business.

A bit about energy minimization problems

A dear friend revealed before me the wonders of energy minimization problems a while back, and ever since I have trying to find uses for that method. Basically, it is trying to find a global minimum for a complicated energy function (usually with many parameters), by following the function’s gradient. Such methods are often called Gradient Descent, and used mostly for non-linear systems that can’t be solved easily using a least-squares variant.

A lot of work in computer vision was done using energy functions (I believe the most seminal was Snakes, over 10,000 citations), usually having two terms: Internal energy and External energy. The equilibrium between the two terms should result in a low-energy system – our optimal result. So we would like to formulate the terms in our system such that when they are 0 – they describe the system as we want it.

Following the works with active contours, I believe the external energy function should have to do with how the hand model fits to the hand blob, and the internal energy will have to do with how “comfortable” the hand is with this configuration.

The hand model

Let’s see how a 2D model of a hand might look like

Kinda looks like a rake… huh?

There are some parts that practically can’t change much, i.e the palm (orange), and some that might change drastically, i.e the fingers (red). Each finger has joints (blue circle), and a tip (bigger blue circle).

typedef struct finger_data {
	Point2d origin_offset;		//base or finger relative to center hand
	double a;					//angle
	vector<double> joints_a;	//angles of joints
	vector<double> joints_d;	//bone length
} FINGER_DATA;

typedef struct hand_data {
	FINGER_DATA fingers[5];		//fingers
	double a;					//angle of whole hand
	Point2d origin;				//center of palm
	Point2d origin_offset;		//offset from center for optimization
	double size;				//relative size of hand = length of a finger
} HAND_DATA;

At first I thought, since I’m only interested in the tips of the fingers, to use Inverse Kinematics to guide the tips to a certain point and let the joints find their own minimal energy position, following this article. But I abandoned this method because of complications.

I also had to simplify this model, for real-time estimation and also better results. So in the end I ended up with a very rigid model, that allows only on joint per finger and no angular movement.

Using tnc.c

tnc.c is a “library”, essentially one c file, that implements a line search algorithm that is able to find the minimum point of a multi-variate function. I’m not certain of the algorithm details, and it’s not so important as it can be replaced with any other similar library. But, tnc.c has a great advantage – it is dead simple. One function will start the gradient decent, calling-back a function to calculate the gradients.

So basically I had to write just one very short function:

static int my_f(double x[], double *f, double g[], void *state) {
	DATA_FOR_TNC* d_ptr = (DATA_FOR_TNC*)state;
	DATA_FOR_TNC new_data = *d_ptr;

	mapVecToData(x,new_data.hand);

	*f = calc_Energy(new_data,*d_ptr);

	//calc gradients
	{
		double _x[SIZE_OF_HAND_DATA];

		for(int i=0;i<SIZE_OF_HAND_DATA;i++) {
			memcpy(_x, x, sizeof(double)*SIZE_OF_HAND_DATA); //reset variables
			_x[i] = _x[i] + EPSILON; //change only one variable
			mapVecToData(_x, new_data.hand);
			double E_epsilon = calc_Energy(new_data,*d_ptr);
			g[i] = ((E_epsilon - *f) / EPSILON); //calc the gradient for this variable change
		}
	}

	return 0;
}

This function is called by tnc.c on every iteration of the search, the double x[] is the state of variables the search is now examining, double* f is the energy for this state, double g[] are the gradients (same size as x[]), and voide* state is a user-defined variable that can be carried along the process.

So what I did is simply changed the value of each parameter in turn, to test how it effects the energy in the system. I get a measure of the energy, then I subtract it from the “natural” setup (without any changes to parameters) energy measure, and I get the gradient for this parameter.

The energy function came out a bit different in the end:

static double calc_Energy(DATA_FOR_TNC& d, DATA_FOR_TNC& orig_d) {
	double _sum = 0.0;

	//external energy: how close are the joints to the hand blob? (how well do they fit to it)
	vector<Point2d> joints;
	Mat tips(5,1,CV_64FC2);

	for (int j=0; j<5; j++) {
		joints.clear();
		FINGER_DATA f = d.hand.fingers[j];
		Point2d _newTip = newTip(f,d.hand,joints); //get joints for this finger

		for (int i=0; i<tmp.size(); i++) { //for each joint find how far it is from the blob
			double ds = pointPolygonTest(d.contour, tmp[i]+getHandOrigin(d.hand), true);
			ds += 5;
			ds = 1 * ((ds < 0) ? -1 : 1) * (ds*ds) ;
			_sum -= (ds > 0) ? 0 : 100*ds;
		}

		tips.at<Point2d>(j,0) = _newTip;
	}

	//lazyness of fingers - joints should strive to be as they were in the natural pose
	vector<double> _angles;
//	for (int j=0; j<5; j++) {
//		FINGER_DATA f = d.hand.fingers[j];
//		FINGER_DATA of = orig_d.hand.fingers[j];
////		_angles.push_back(f.a - of.a);
//		for (int i=0; i<f.joints_d.size(); i++) {
////			_angles.push_back(f.joints_a[i] - of.joints_a[i]);
//			_angles.push_back(f.joints_d[i] - of.joints_d[i]);
//		}
//	}
	_angles.push_back(d.hand.a-orig_d.hand.a); //the angle of the hand should be as it was before
	_sum  += 10000*norm(Mat(_angles));

	if(_sum < 0) return 0;
	return _sum;
}

You’ll notice the commented out section. The “laziness of fingers” turned out not to give good results… A different metric is needed! I have not found it yet, maybe you have a good idea?

Starting tnc.c is very simple: Allocating the vectors for X and gradients, initializing the model from the blob, and calling the simple_tnc convenience method. simple_tnc starts tnc with some default parameters that don’t affect the outcome (at least in my tries).

void estimateHand(Mat& mymask) {
	double _x[SIZE_OF_HAND_DATA] = {0};
	Mat X(1,SIZE_OF_HAND_DATA,CV_64FC1,_x);
	double f;
	Mat gradients(Size(SIZE_OF_HAND_DATA,1),CV_64FC1,Scalar(0));

	namedWindow("state");

	initialize_hand_data(d, mymask);

	mapDataToVec((double*)X.data, d.hand);

	simple_tnc(SIZE_OF_HAND_DATA, (double*)X.data, &f, (double*)gradients.data, my_f, (void*)&d, 1, 0);

	mapVecToData((double*)X.data, d.hand);
	showstate(d,1);

	d.hand.origin = getHandOrigin(d.hand); //move to new position
}

Results and Discussion

Here are my results so far:

It’s not perfect, but it’s a start. Tracking and estimating open hand is pretty good, with some orientation change as well. But when the fingers are closed… that’s where problems start.

Sometimes the joints “hover” over the black area to “land” in a white area so they “fit”, but they should not do that. One easy thing to do to counter this is to measure the distance of the whole bone, and not just the joint.

The model right now doesn’t use all the joints possible, because it is too heavy computationally. Plus the energy does not depend (or change) the angle of the fingers. So this is a very very simple model of a hand…

But, it is a good start! All the other stuff I have seen online is just basic high-curvature points counting and color-based or feature-based segmentation and tracking… My model actually tries to fit an articulate and precise model of a hand to the image.

How did you get such nice blobs?!

You ask. They are beautiful aren’t they… nice and clean, easy for tracking and model fitting. It’s no magic though…
Well, I took part of a project in the Media Lab, called DepthJS, that uses the MS Kinect to control web pages. I wrote the computer-vision part. So all the code is there, you can grab it, I just plugged it into this little project. Basing off this very simple example of using OpenCV2.X and libfreenect.

Wow, this was a longie.. I hope you learned something and got inspired. I got to do a second overview of the project, and I’m inspired. Inspiration all around!

Code is obviously yours for the taking:
https://github.com/royshil/OpenHPE

Please contribute your own views, thoughts, code, rants in the comments and github page.

Enjoy
Roy.

It can also work for you, in case your IT does not block by protocol, only by address.

So here’s how to do it:

STEP 1 – Retrieve the actual link for your radio station

Go to the station’s website and try to get a link that you can play in Windows Media Center.
Some stations will let you find it, others won’t.
If this is the case, here’s what you need to do (At home!)

1. Download wireshark and install it
2. Start capturing using this filter: rtsp.request
3. Try to listen to the station
4. You should see such an output in wireshark:

   

   As you can see, there is a url here that looks like this:
   rtsp://someurl/somefile RTSP/1.0

5. Take this URL, and replace RTSP with MMS and omit the RTSP/1.0 ending.
   Your URL should look like this: mms://someurl.somefile
6. Try to play this URK in windows media player. If it works – you’re half way through

If you can get the link in any other way, it’s fine… This is only a suggestion

STEP 2 – Set up VLC as a stream server at your home

I will start with an apology. I didn’t find a proper way to do it with the GUI of version 1.0+.
On the past versions it was relatively clear, so that’s where I managed to find the command line you need to run in order for it to work
So, at this point, you need to run VLC on your PC with these parameters:

vlc mms://yourserver/yourlink :sout=#transcode{acodec=mp3,ab=64,channels=2}:duplicate{dst=std{access=mmsh,mux=asfh,dst=:8080}}

This will stream the web-radio station to port 8080.
You can test this using Windows Media Player, just open it up, and open the url mms://localhost:8080

Another thing you need to keep in mind, is that you should establish port forwarding if you are behind NAT.

 That’s the whole deal… Of course you can improve it by creating a script that will run it, or add the http interface of VLC to remote control it on another port, but I don’t want to overload this guide…

keep it simple!

Image<Color>* load( std::string file_name )
{
 if( file_name.find( ".pgm" ) != std::string::npos )
 {
 return loadFromPGM( file_name );
 }

 else if( file_name.find( ".ppm" ) != std::string::npos )
 {
 return loadFromPPM( file_name );
 }

 else
 {
 return loadOpenCV(file_name);
 }
}

void fromImageMaskToIplImage(const Image<Real>* image, IplImage* ipli) {
 for(int x=0;x<image->width();x++) {
 for(int y=0;y<image->height();y++) {
 //Color c = (*image)(x,y);
 Real r = (*image)(x,y);
 CvScalar s = cvScalarAll(0);
 if(r == 0.0) {
 s.val[0] = 255.0;
 }
 cvSet2D(ipli,ipli->height - y - 1,x,s);
 }
 }
}

Image<Color>* loadIplImage(IplImage* im) {
 Image<Color>* image = new Image<Color>(im->width, im->height);
 for(int x=0;x<im->width;x++) {
 for(int y=0;y<im->height;y++) {
 CvScalar v = cvGet2D(im,im->height-y-1,x);
 Real R, G, B;
 R = (Real)((unsigned char)v.val[2])/255.0f;
 G = (Real)((unsigned char)v.val[1])/255.0f;
 B = (Real)((unsigned char)v.val[0])/255.0f;
 (*image)(x,y) = Color(R,G,B);
 }
 }
 return image;
}

Image<Color>* loadOpenCV(std::string file_name) {
 IplImage* im = cvLoadImage(file_name.c_str(),1);
 Image<Color>* i = loadIplImage(im);
 cvReleaseImage(&im);
 return i;
}

Well, there’s nothing fancy here, but it does give you a fully working GrabCut implementation on top of OpenCV… so there’s the contribution.

GrabCutNS::Image<GrabCutNS::Color>* imageGC = GrabCutNS::loadIplImage(orig);
 GrabCutNS::Image<GrabCutNS::Color>* maskGC = GrabCutNS::loadIplImage(mask);

 GrabCutNS::GrabCut *grabCut = new GrabCutNS::GrabCut( imageGC );
 grabCut->initializeWithMask(maskGC);
 grabCut->fitGMMs();
 //grabCut->refineOnce();
 grabCut->refine();

 IplImage* __GCtmp = cvCreateImage(cvSize(orig->width,orig->height),8,1);
 GrabCutNS::fromImageMaskToIplImage(grabCut->getAlphaImage(),__GCtmp);
 //cvShowImage("result",image);
 cvShowImage("tmp",__GCtmp);
 cvWaitKey(30);

I also added the GrabCutNS namespace, to differentiate the Image class from the rest of the code (that probably has an Image already).

Code is as usual available online in the SVN repo.

Enjoy!

Roy.

My mobile company allows you to send 10 free daily SMS through their website, and after that each text message is still half priced, so I decided to take a challenge and create a UI that allows me to send my messages from the phone through the website automatically.

The core of my software was pure java, so even though it wasn’t straight forward to accomplish, I kinda know the material.

The main issues were after – when I got to the android implementation and UI

Here are the issues I needed, and will supply examples for in this post:
(Of course – for you that are more experienced than me with Android development, please forgive if I’m not doing everything ‘by the book’, it’s simply what I could find. So if you have any suggestions or improvement please send them to me or post a comment J )

• How to find out if there is an active network on the device
• How to create options menu
• How to create and clear notification in the notification area
• How to declare your program as “SMS Sender” (‘Complete action using…’)
• Taking care of orientation (Landscape and Portrait mode for UI)

Here is the code I ended up using. Hope you find it helpful

This sample method returns a Boolean that states if there is an active network

private boolean anyNetworkActive() {
         TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
         WifiManager wm = (WifiManager) getSystemService(Context.WIFI_SERVICE);
         WifiInfo wi = wm.getConnectionInfo();
         return !((wi == null || WifiInfo.getDetailedStateOf(wi.getSupplicantState()) == DetailedState.IDLE) &&
tm.getDataState() != TelephonyManager.DATA_CONNECTED);
}

These events populate the menu with text-only options, and do the proper action when pressed

@Override
public boolean onCreateOptionsMenu(Menu menu) {
      menu.add(getString(R.string.menuconfig));
      menu.add(getString(R.string.menuclear));
      menu.add(getString(R.string.menucontact));
      return super.onCreateOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
      if (item.getTitle().equals(getString(R.string.menuconfig)))
      // Show config screen
      startActivity(new Intent(this, Prefs.class));
      if (item.getTitle().equals(getString(R.string.menuclear))) {
      // Clear all fields on screen
           messageBody.setText("");
           smsTarget.setText("");
      }
      if (item.getTitle().equals(getString(R.string.menucontact))) {
            getcontact = true; // for sync issues
           // Delete the contactnum variable
           prefs.edit().putString("contactnum", "").commit();
           // Show contact selection screen
           startActivity(new Intent(this, ContactList.class));
       }
       return (true);
}

The first method will create a notification for your user (an icon must be present in the drawable folder)
The second one will clear the notification

public void notifyString(String sTickerText, String sContentTitle, String sContentText) {
          String ns = Context.NOTIFICATION_SERVICE;
          NotificationManager mNotificationManager = (NotificationManager) getSystemService(ns);
          int icon = R.drawable.notification_icon;
          CharSequence tickerText = sTickerText;
          long when = System.currentTimeMillis();

          Notification notification = new Notification(icon, tickerText, when);
          Context context = getApplicationContext();
          CharSequence contentTitle = sContentTitle;
          CharSequence contentText = sContentText;
          Intent notificationIntent = new Intent(this, PeleSms.class);
          PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);

          notification.setLatestEventInfo(context, contentTitle, contentText, contentIntent);
          final int HELLO_ID = 1;

          mNotificationManager.notify(HELLO_ID, notification);
}

public void clearNotification() {
          String ns = Context.NOTIFICATION_SERVICE;
          NotificationManager mNotificationManager = (NotificationManager) getSystemService(ns);
          mNotificationManager.cancel(1);
}

These methods and AndroidManifest.xml changes will declare your program as an SMS Sender, and the user will be asked if he/she wants to use it instead of the built in messaging client when trying to send a text message (with the “Complete action using…” menu, screenshot above)

AndroidManifest.xml:

<intent-filter>
     <action android:name="android.intent.action.VIEW" />
     <action android:name="android.intent.action.SENDTO" />
     <category android:name="android.intent.category.DEFAULT" />
     <category android:name="android.intent.category.BROWSABLE" />
     <data android:scheme="sms" />
     <data android:scheme="smsto" />
</intent-filter>

Catching the intent in the beginning of activity:

@Override
public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         String param = getIntent().getDataString();
          ....

Orientation:

The grand finale. This is as simple as can be… no code needed. All you need to do, is create two folders under the root of your project: layout-port and layout-land
Then, move your UI XML to the layout-port folder, and create a copy of it with the same name in layout-land folder. That’s about it. Of course, you need to adjust the layout for each. Android will know when to use which

Well, I hope I got you through rough times if you found this post useful. I know I wish I bumped into one like it J

Last thing: This is a ListActivity I created using some examples I found… It displays a list of your contacts and by clicking one, saves his phone number in a Shared Preference. Note that you must grant permission for reading contact in your AndroidManifest.xml

public class ContactList extends ListActivity{
private ListAdapter mAdapter;
SharedPreferences prefs;

/** Called when the activity is first created. */
@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        prefs = PreferenceManager.getDefaultSharedPreferences(this);
        Cursor contactsCursor = this.managedQuery(People.CONTENT_URI,
                     null, null, null, "People.NAME ASC");
        startManagingCursor(contactsCursor);

        String[] columnsToMap = new String[] {People.NAME};
        int[] mapTo = new int[] {android.R.id.text1};

        mAdapter = new SimpleCursorAdapter(this,
                     android.R.layout.simple_list_item_1,
                     contactsCursor, columnsToMap, mapTo);
        this.setListAdapter(mAdapter);
}

@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
// TODO Auto-generated method stub
super.onListItemClick(l, v, position, id);
Cursor C = (Cursor) mAdapter.getItem(position);
String phoneNumber;
int phoneColumn = C.getColumnIndex(People.NUMBER);
phoneNumber = C.getString(phoneColumn);

//SharedPreferences.Editor editor =
prefs.edit().putString("contactnum", phoneNumber).commit();

finish();
}
}

That’s about it… If you need more info on anything I’ve posted here just contact me or leave a comment

UPDATE: I have added some code to our project repository SVN.
It does not contain the actual backend SMS sending, since this is pure java thing, and I don’t want to piss off my cellular company (making them stop giving away 10 free per day maybe? ). The project name is AndroidFirstSteps
http://morethantechnical.googlecode.com/svn/trunk/

I recently did a small project combining a Java web service with a OpenCV processing. I tried to transfer the picture from Java environment (as BufferedImage) to OpenCV (IplImage) as seamlessly as possible. This proved a but tricky, especially the Java part where you need to create your own buffer for the image, but it worked out nicely.

Let me show you how I did it

First up was creating a 3-component RGB BufferedImage in Java, with a custom memory buffer that will fit nicely with IplImages:

private BufferedImage createOpenCVCompatibleBufferedImage(int w, int h)
{
ComponentColorModel cm = new ComponentColorModel(
ColorSpace.getInstance(ColorSpace.CS_sRGB),
false,  //no alpha channel
false,  //not premultiplied
ColorModel.OPAQUE,
DataBuffer.TYPE_BYTE); //important - data in the buffer is saved by the byte

SampleModel sm = cm.createCompatibleSampleModel(w, h);
DataBufferByte db = new DataBufferByte(w*h*3); //3 channels buffer
WritableRaster r = WritableRaster.createWritableRaster(sm, db, new Point(0,0));
BufferedImage bm = new BufferedImage(cm,r,false,null);
return bm;
}

This took some trial and error, but I ended up with a working thing.

Now, the C++/OpenCV side of things – a JNI function to read the buffer and do some OpenCV stuff:

JNIEXPORT jint JNICALL Java_test_OpenCVShowImage
(JNIEnv *env, jobject jo, jbyteArray pic, jint w, jint h, jint bpp, jint bpr) {
IplImage* img;
jint len;
unsigned char* result;
int n1;

img = cvCreateImageHeader(cvSize(w,h),8,bpp/8); //create the "shell"

len = (*env)->GetArrayLength(env, pic);
result = (unsigned char *)malloc(len + 1);
if (result == 0) {
fatal_error("out of memory");
(*env)->DeleteLocalRef(env, pic);
return 0;
}
(*env)->GetByteArrayRegion(env, pic, 0, len,(jbyte *)result);

cvSetData(img,result,bpr);    //set the buffer

cvNamedWindow("window");
cvShowImage("window",img);
cvWaitKey(0);
cvDestroyWindow("window");

free(result);
cvReleaseImage(&img);
return 1;
}

One last thing -the Java call to the JNI function:

BufferedImage tmp = ImageIO.read(new File("bird.png"));

BufferedImage bi1 = createOpenCVCompatibleBufferedImage(tmp.getWidth(), tmp.getHeight());

//paint the image with a little transform...
Graphics2D biDestG2D = bi1.createGraphics();
biDestG2D.setColor(Color.white);
biDestG2D.fillRect(0, 0, w, h);
AffineTransform transform = AffineTransform.getShearInstance(0.2, 0.1);
transform.scale(0.5, 0.5);
biDestG2D.drawImage(tmp,transform,null);
biDestG2D.dispose();

byte[] bytes = ((DataBufferByte)bi1.getRaster().getDataBuffer()).getData();

OpenCVShowImage(bytes, w, h, 24, w*3);

That’s all folks!

Just wanted to report on a breakthrough in my iPhone-CV digging. I found a true realtime frame grabber for the iPhone preview frame (15fps of ~400×300 video), and successfully integrated this video feed with a pure C++ implementation of the MeanShift tracking algorithm. The whole setup runs at realtime, under a few constraints of course, and gives nice results.

Update: Apple officially supports camera video pixel buffers in iOS 4.x using AVFoundation, here’s sample code from Apple developer.

So lets dig in…

First up is the frame grabber.

I was truly amazed by how far people went with getting the video stream of the iPhone camera. NDAs were tossed out the window, Private Frameworks are hardly private anymore, and people went further on. The impl I found hooks up onto the private callback function of the camera to PLCameraController, mind you this was probably hidden deep down in PhotoLibrary.

The gifted hacker, Norio Nomura, published his code for doing this here. I found on a long thread of rants about how the only way to grab frames off the camera preview was using UIGraphics’s UIGetScreenImage(). He sure showed them…

Anyway, his code led me to a few tweaks needed to process the frame data in real-time. What he does is update his static buffer pointer, readpixels, to the CoreSurface Surface object’s buffer, so you always have a pointer to the pixel data. Sweet. But now we need to process this data somehow, and moreover, we need to know the width, height, bytes per pixel and bytes per row.

So I created a few more static variables, and added a few functions in CameraTestAppDelegate to return these values. Now I can access the pixels correctly.

On to the MeanShift.

The algorithm is very simple:

1. Calculate the histogram of the object (you assume the user had marked it in the first frame)
2. In the next frame, for which you don’t know where the object is, calculate the average point of all the pixels that “conform best” with your histogram, in a certain area around the known center.
3. Move iteratively towards your average point, until convergence.

I found a pure c++ implementation of a version of MeanShift from a turkish student in Bilkent University, Halil Cuce. It works perfectly for my needs, and compiles out-of-the-box as it has no external libraries dependencies.

It has room for a few fixes though:

• CObjectTracker::CheckEdgeExistance needs to use “GetBValue” instead of “GetGValue” in the last additives.
• CObjectTracker::GetPixelValues should not use m_nImageWidth as the “number of bytes in a row”, a new member should be introduced which represents the row-stepping.
• Many optimizations can be done, for example in the CObjectTracker::FindHistogram function, the for loops can be optimized by pre-calculating the start and end values of Y and X iterators.

But all-in-all it gives nice results. The main problem is high CPU rates whne tracking large objects. I found that 40×40 objects can be tracked in ~15fps, but anything larger than that will severely damage fps rates.

OK, time for a video:

As usual… I cannot release my portions of the code as-is in here as it is protected by my company, I can only refer you to the online sources available. Contact me by commenting or mail if you want code.

Enjoy,

Roy.

I found that Word Clouds, a kind-of new visualization concept, have a good trait of focusing the attention over a single word’s associative space. You bold your main word, center it, and scatter the associative words around it. This creates a powerful effect.

I found a nice tool to create these word coulds on-the-fly: Wordle.

The way I did was, get the Wikipedia value of my word, for example “Friendship“, and go to the Edit tab. Copy all the textarea’s contents, and paste it into Wordle’s word cloud creator. Press “GO” and the results are immediate.

You can eliminate the “outliers” – those unrelated words that appear too many times, and layout the cloud as you like to fit your slide.

The down-side with Wordle is that it has no export ability, so I had to take an Alt-PrintScreen screenshot to get my cloud as a picture.

Enjoy!

Roy.

Morning traffic jams can really bum you out on some days, and most people try to avoid them. But actually doing it takes a bit of practice and a lot of time, so it took me just 3 years to perfect my morning route to work. I think I am now able to shave off between 5 and 20 minutes of traffic every day, depends on how crowded the roads are that day.

On a “light” day these tips aren’t worth much, but on a crowded day (like today) it can really save time and gas. Also, since this is my route to work, and I live in Israel and work in Ramat Ha’hayal Tel-Aviv, the example images are in Hebrew and they help people who need to get to Habarzel street. But the tips are genuine, and can help anyone optimize thier morning route.

OK, so on to the point.

My route is about 9-10 km, very short, but some days it can take up to 40 mins to get into work. Most of the problem is caused by traffic lights, which are terribly unbalanced for some directions. So tip #1 is: shift the lights balance to your favour. Change the route to take the better, longer green lights.

Here’s an example:

This is an actual traffic light which is unbalanced towards the people on “Keren Kayemet” (the yellow road). Every morning there’s a congestion on the side of the people coming from the highway.

My trick is to skip the direct left turn, which is unbalanced (can be 3 min for a green of 15 sec), and after a short round trip in the neighbourhood I take the same light but in the more favourable direction. On a heavy day this can save over 10 min of just sitting in the car waiting for the short green.

Next tip, #2: Take the lighter road, even if its longer.

Another example:

So when I come up to this intersection there are 2 choices: either go with the crowd and turn left, or go straight ahead and into the neighbourhood.

Going into the neighbourhood seems like a foolish idea, since there are speed bumps, pedestrian crossings and more turns. But as it turns out, taking the neighbourhood in this case is better in a few ways:

• Note the destination road (“Raul Valenberg”). Since most people come from the purple route, the traffic lights there are really crowded. On some days you can wait for 3-4 lights untill you take your turn. The opposite direction of that street is not always light on cars – but you don’t have a light to make the right turn. So taking this direction is preferable, but in order to get to take the street in the opposite direction you have zigzag around the neighbourhood a little. But trust me – it pays off.
• Its clear to see that the purple road is shorter, broader and more direct, but these things also make it more crowded. Sometimes the longer, narrower and less direct road is actually the faster one!

There are shortcomings to going through the neighbourhoods like: pedestrians, driving school cars (and trucks!) that go about slowely, speedbumps and the occasional police car. But in some cases its worth it if in the end you take the better direction.

Last tip, #3: explore your route. Every few weeks explore the streets around your usual route, even if it takes a few more minutes, you might just hit that secret path no one ever takes!

Have a safe morning trip!

Roy.