Some of its features:

• 5 Megapixel Sensor 2592 x 1944
• Supports 1080p30 / 720p60 / 640x480p Video
• 25mm x 20mm x 9mm Footprint
• You can see all the config options and possibilities that this camera has: RaspyCamDocs

Finally, I want to show you how this camera takes the picture in not very good conditions of light

]]> http://blog.rocapal.org/?feed=rss2&p=614 0 http://blog.rocapal.org/?p=560 http://blog.rocapal.org/?p=560#comments Tue, 21 May 2013 10:20:30 +0000 rocapal http://blog.rocapal.org/?p=560 “The final conclusion of Android Team is that Serializable in JAVA is far too slow to satisfy Android’s interprocess-communication requirements. So the team built the Parcelable solution”. Just read this sentence is enough to forget Serializable mechanism. But, I want to show you how the faster is Parcelable in comparison with Serializable. We are going to measure the time it takes to pass a structure in Android using the intent when we start a new activity.

We have around 340 nodes into ArrayList structure. Each node is a simple class that contains two String attributes and one Double attribute.

1
2
3
4
5

public class Foo  {  //implements Parcelable or Serializable
	private String mVar1;
	private Double mVar2
	private String mVar3;
}

This is the way how we pass the date if the structure is Serializable

1
2
3
4
5
6
7
8
9

// Code of Activity1
ArrayList array = fillArray();
Intent popupIntent = new Intent(this, Activity2.class);
popupIntent.putExtra("key_array", array);
startActivity(popupIntent);
 
// Code of Activity2
Intent i = getIntent();
ArrayList array = i.getSerializableExtra("key_array"));

And this is the way how we pass the date if the structure is Parcelable

1
2
3
4
5
6
7
8
9

//Code of Activity1
ArrayList array = fillArray();
Intent popupIntent = new Intent(this, Activity2.class);
popupIntent.putParcelableArrayListExtra("key_array", array);
startActivity(popupIntent);
 
//Code of Activity2
Intent i = getIntent();
ArrayList array = i.getParcelableArrayListExtra("key_array");

Finally, you can see the times of this experiment. I’ve measured the time it takes to pass the structure in both cases (Serializable and Parcelable). The results are overwhelming.

We can conclude that Parcelable is around 15 times faster than Serializable!!

Implement parcelable structure requires a little effort because is needed implement two methods for the serialization of the object, but it’s highly recommended do it.

• DateTime: 2013/05/04 11:33 (UTC+0)
• Temperature: 20.62 ºC
• Altitude: 1174.70 m
• Speed: 78.2 km/h
• Picture:

• Location:

OMG! It’s amazing!

There are several solutions out of android to show video streaming. Some of them provide SDK to develop. But if you don’t want develop to other SDK, you can use VLC for android. Thanks to the intent’s communication of Android, we can interact with VLC Android app.

1
2
3
4

Intent i = new Intent("org.videolan.vlc.VLCApplication.gui.video.VideoPlayerActivity");
i.setAction(Intent.ACTION_VIEW);		
i.setData(Uri.parse("rtsp://your_url:554/"));
startActivity(i);

If you are interested to know how I get these lines, keep reading.
Maybe, you ask yourself “how do I find the correct name of activity and parameters?”. Well, this is not magic. In general, if you want interact with a specific android application and you have access to source code (FLOSS blessed!), follow these steps.

1. Download the source code

In our case, we download VLC for android source code by git

1

git clone git://git.videolan.org/vlc-ports/android.git

2. Let’s see AndroidManifest.xml file

Take a moment to see and analyze the AndrodManifest.xml file of VLC for Android project. Quickly you see that exist one activity declared in the manifest that have a lot of intent-filter. The activity is “.gui.video.VideoPlayerActivity”. If you keep looking, you notice that one intent-filter declared the protocols that support this activity and the action of the intent

1
2
3
4
5
6
7
8
9
10
11
12
13

<activity android:name=".gui.video.VideoPlayerActivity" 
          android:configChanges="orientation|screenSize" 
          android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
   <!--  This filter captures protocols without type info  -->
   <intent-filter>
       <action android:name="android.intent.action.VIEW"/>
       <category android:name="android.intent.category.DEFAULT"/>
       <category android:name="android.intent.category.BROWSABLE"/>
 
       <data android:scheme="rtmp"/>
       <data android:scheme="rtmpe"/>
       <data android:scheme="rtp"/>
       <data android:scheme="rtsp"/>

So, we have the name of the activity (VideoPlayerActivity) and the action of the intent (action.VIEW).

3. Let’s see JAVA source code

Well, just we have to know how send the data. In our case, we want to send the URI that represents the url of video rtsp. Normally, the data in the intents is sent using setData method.

1

i.setData(Uri.parse("rtsp://your_url:5554/"));

But it’s possible that the developer of the other application use the putExtra methods to send the data. Also, you have to know the name of param.

1

i.putExtra("URL_STREAMING", Uri.parse("rtsp://your_url:5554/"));

Let’s see how VLC for Android app implement this feature. Take a look at VideoPlayerActivity file. If you search by getIntent() (you know, it’s the method that android developers uses to know the Intent sent), you get the load() method. If you pay attention in this method, you can see the following lines that say you how the date is sent.

1
2

Cursor cursor = managedQuery(getIntent().getData(), new String[]{ MediaStore.Video.Media.DATA }, null, null, null);
mLocation = getIntent().getData().getPath();

Also, you can see they use getExtras() to get optional parameters in the intent call.

1

itemTitle = getIntent().getExtras().getString("itemTitle");

So, you can send the uri of rtsp video and the title that you want VLC android show in the screen. The source code would:

1
2
3
4
5

Intent i = new Intent("org.videolan.vlc.VLCApplication.gui.video.VideoPlayerActivity");
i.setAction(Intent.ACTION_VIEW);		
i.setData(Uri.parse("rtsp://your_url:5554/"));
i.putExtra("itemTitle", "your video title");
startActivity(i);

As a general rule, if you get access to source code or at least access to AndroidManifest file you’ll know how interact with this android application.

1
2
3

vega:$/android/sdk/platform-tools$ file aapt
aapt: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically 
linked (uses shared libs), for GNU/Linux 2.6.8, not stripped

Installing ia32-libs package was enough to solve this problem, but this package doesn’t install correctly in debian sid. It has been replace by Debian-Multiarch

1
2
3
4
5
6
7
8
9
10
11
12
13

vega:/home/rocapal/android/sdk/platform-tools$ aptitude install ia32-libs
Se instalarán los siguiente paquetes NUEVOS:
ia32-libs{b}
0 paquetes actualizados, 1 nuevos instalados, 0 para eliminar y 7 sin actualizar.
Necesito descargar 114 kB de ficheros. Después de desempaquetar se usarán 114 kB.
No se satisfacen las dependencias de los siguientes paquetes:
ia32-libs : Depende: ia32-libs-i386 que es un paquete virtual.
Las acciones siguientes resolverán estas dependencias
 
Mantener los paquetes siguientes en la versión actual:
1) ia32-libs [Sin instalar]
 
¿Acepta esta solución? [Y/n/q/?]

So, the solution is to install the following packages (and its dependencies)

1

$ aptitude install lib32stdc++6 lib32z1

Also you can see Debian-Multiarch that replaces to ia32-libs package. Just you have to add i386 architecture in dpkg system to install i386 dependecies that you need.

1
2
3

$ dpkg --add-architecture i386
$ aptitude update
$ aptitude upgrade

Enjoy android coding!

As you can see in the following figure you can get a linear regression (red line) or you can get a non-linear regression (blue and  yellow) if you add more features to your equation. The type of curve of non-linear regression model depends of the grade of your polynomial. If the grade of the polynomial is near 1 the model fits to traditional linear regression model. Instead, if the grade of the polynomial is high the model fits to training points.

OverFitting is the term that it’s used to describe when your linear regression model don’t have capacity to predict because the model fits very near of the training points. This fact can happen if the model is very complex or the grade of equation is high. You notice that over-fitting is bad for your model and you should avoid it because the predictions will be very similar or equals to the training points.

You can play in live with this concept about polynomial regression in the following link: http://www.arachnoid.com/polysolve/index.html

Also you can get the source code of this example from my GIT repository.

I use the following ffmpeg command to record screencast (audio+video) of the desktop and Android emulator:

ffmpeg -f alsa -i plughw:0 -f x11grab -s 1680x1050
-r 24 -b 200k -bf 2 -g 300 -i :0.0
-ar 11050 -ab 64k -acodec libmp3lame
-vcodec libxvid -aspect 1.555 -sameq outputFile.avi

To avoid problems with the audio recording you must configurate your android emulator with the following keys:

Audio PlayBack Support =  NO / FALSE
Audio Recording Support = NO / FALSE

]]> http://blog.rocapal.org/?feed=rss2&p=402 0 http://blog.rocapal.org/?p=351 http://blog.rocapal.org/?p=351#comments Thu, 19 Apr 2012 10:07:56 +0000 rocapal http://blog.rocapal.org/?p=351 I continue working with machine learning algorithms. In a previous post I talked about linear regression with one variable and I described different algorithms to predict hypothesis.

In this case, I’m playing with linear regression but, with some features. Linear regression only have one input feature and one output feature. For example, you can predict the price of a house give the house’s size. But imagine that you want predict the price of a house using size and rooms features. When you have more than one input feature is called ‘multi-variable linear regression’.

In the following figure we can see the two input features (size and rooms), the training data (red dots), and the predictions (blue dots). In this case, we can represent the information with a 3D model. If your model have more than three features you must research the way to represent all the data.

For a house with 70m and  2 rooms, we predict a price of 143496.23€
For a house with 100m and 3 rooms, we predict a price of 203095.22€
For a house with 175m and 4 rooms, we predict a price of 363570.19€

It’s important notice that in this case we are working in 3D space, so the regression model is represented by a plane (instead of line, as one-variable linear regression model). In the following figures you can see how the predictions dots are on the plane. We obtain always a plane regression if we are using three variables and none of them are quadratic or cubic features. Thanks to mplot3d library you can render 3D graphics and move the perspective of the figure to see the regression plane from different points of view.

The first model that I have studied is linear regression. This model consist in have a relation between two or more variables. For example, in my example I have a training data about the prices of the houses and its size in square meters. This training data is used to build a linear regression model to predict the prices of the house give the size of the house. As you  can see in the following figure, the black dots show the training data (I did web crawling to get real data). The blue line represents the trend line of the model, and the red dots show the predicts for two size of houses.

You can see the prediction values that are represented by red dots in the figure.

For a house with 100 meters, we predict a price of 202906.39 euros
For a house with 175 meters, we predict a price of 354343.54 euros

You can use Octave or R to practice and implement machine learning algorithms. Personally, I prefer to use a great and FLOSS library that I found, scitik-learn. This library has several implementations of linear models: LinearRegression, RidgeRegression, Lasso, Elastic Net, …. For this example, I have used the SGDRegressor model but, I want to test other models more smooth like Lasso or Elastic models.

You can get the source code of this example in my GIT repository

]]> http://blog.rocapal.org/?feed=rss2&p=312 0 http://blog.rocapal.org/?p=277 http://blog.rocapal.org/?p=277#comments Fri, 18 Nov 2011 09:49:29 +0000 rocapal http://blog.rocapal.org/?p=277 Decompile is a process to revert the compile operation. I main, decompile converts the low level code in high level code. The Android application is compiled in APK container that groups files as: xml, images and class. APK containers are actually ZIP containers. An interest thing is can see the xml configuration or some source code of others applications. If this applications are Free Software is not a problem, but if this applications are privated we can’t see its configuration. The next application help you to decompile an APK file to see xml configuration and source code.

Some tools I’ve found:

• APKTool: Decompile all the configuration XML and resources as images. It’s great to view AndroidManifest.xml or some layout xml. The source code is decompiled to “smali”. This assembler language is based in dalvik but it’s not translate to JAVA.
• dex2jar: If we unzip the APK file we find a .dex files. This tools translate .dex file to JAR file with all the class files of the project. So, you can use any class2java decompiler to view source code
• JAD Java Decompiler: It’s widely used through command line and very useful to make scripts by automatic process
• JDGUI: Graphic decompiler and integrated with eclipse. It’s not a efficient solution to run process in background.