DsynFLO

within future: Chrome-Android may seek unification and Microsoft Watch is coming soon

2014-10-29T09:26:00.002-07:00

In our previous post we covered a lot of ground regarding Smartwatches and Eco-system. Few of the interesting things that came out of that discussion was the co-existence of Chrome and Android. A constant remainder is not enough to suggest that Google did not have a stable and independent platform until Android took off. Now with the significant stronghold they have on smart phones, Google is making amendments within the Organization to tweak up its other portal to the Internet by garnishing it with Android. Chrome OS that hasn't really grown out of its infancy yet and is constantly hurtled by Windows releases. The best possible attempt for Chrome is to hijack Android market share by providing itself the ability to run Android applications natively and by pushing the "web-based" capabilities to Android. The above picture exactly illustrates what Canonical did with Ubuntu for Android.

Hiding between the lines

Yet another interesting topic that came out in the post, was the evidently missing Microsoft's Smartwatch. News reports suggest that Microsoft watch will be out with this years end [2014]. The Windows platform is much better equipped to adopt smaller devices thanks to improvements in Windows RT. But the big question is will the plunge into making hardware burn fingers again ?

A mock-up of the Microsoft (Windows/Surface?) Watch -

Related: The Best Smart Watch ever
Sources: CNET, WallStreet.org, VCPost

OpenCV: QR Code detection and extraction

2014-10-25T07:52:00.000-07:00

There are many ways to decode QR Code these days. Here is an attempt to detect QR Code in an image to manipulate within OpenCV.

1. Detection of QR Code Identification markers

We start of the topic by discussing something that is not a part of this sample program. If you need to get on with it, you can skip directly to "Step 1".

The first task is to identify reliable patterns in the QR Code as show above. This can be determined using the technique described below.

A hypothetical Ratio Theorem:

Definition: Ratio of the Areas of N number of two dimensional polygons remain invariant to the uniform geometric transformation.

If a_r is the area of a polygon r then,

a₁ : a_2...: a_N = R in 2D plane X then,

a’₁ : a’_{2 ...} : a’_N = R for any other 2D plane Y which is geometric transformation of X

Consider the following example marker in 2D plane A, the areas of the polygons a₁, a₂and a₃are in the ratio 7:5:3. Plane B is obtained by perspective transformation of plane A. However the areas of the polygons a'₁, a'₂and a'₃plane B can be resolved as multiple of 7, 5 and 3 respectively i.e., 7β:5β:3β or simply 7:5:3. The same is illustrated in the figure below-

Ratio of the areas of the polygons

Proof: I have none. May be some other time.

All great men are gifted with intuition. They know without reasoning or analysis, what they need to know.

This approach is not used in the sample program, instead the structured OpenCV Contour detection technique is used.

Actual Step 1

OpenCV Countour detection does much more then identifying contours in an image. It also stores the relationship and hierarchy amongst the contours. This is nicely explained in the OpenCV documentations and tutorials OpenCV Contour Hierarchy.

Applying contour detection to a QR Code, the contour tracing the perimeter of the pattern polygons has the following characteristics -

It is a contour with subsequent enclosed (nested) contours. Although looking at an Identification marker, you would expect to detect 3 'nested' contours, however the inner boundary is also accounted as a contour resulting in 5 nested contours as shown here.

Nested contours in Identification marker

2. Determining the three distinct Identification markers

Post identification the three markers of the QR Code, the key step now is to determine the orientation of the markers and the positions wrt each other. (i.e., to determine which among the three markers are top, right, bottom and in what order.)

This is achieved easily using a triangle. The triangle is formed by using the mass centers of each of the three contours as vertices. The Vertex not involved in the largest side is obviously out lying and turns out to be the "top" marker*. Differentiating markers "right" and "bottom" out of the remaining two vertices, requires calculating the slope of the line they form and the position of the marker "top" wrt to this line.

* Limitation: This assumption is not true for acute perspective angles. a different approach is required to resolve and is a limitation of current implementation.

Determination of QR Code Identification Markers

3. Identify the four corners of each Identification markers

In this step we provide the contour points of the polygon to the function which retrieves the four corners of the polygon. The method measures the distance of each point on the perimeter with the center to determine four farthest points. These are likely to be the vertices of the polygon.

This function is implemented and well documented as part of OpenAR. More info openAR.

4. Determining the fourth point of the QR Code

Once four corners of all the three identification markers are obtained it is easy to estimate the fourth corner of the QR Code. The estimation is done by extending the lines forming the boundaries of the other two identification markers namely RIGHT and BOTTOM as shown in the figure below.

The line formed by O[3] and O[2] in BOTTOM identification marker is extended. Similarly line formed by M[1] and M[2] of RIGHT identification marker is extended to meet at N,this estimated position serves as the forth corner of the QR Code.

Reference identification objects in the QR Code

5. Orientation and Perspective correction

Having now obtained the 4 corners of the QR Code, namely L[0], M[1], N and O[3], we can apply OpenCV warpPerspective() function to restore the QR Code to readable position.

QR Code Orientation

6. QR Code decoding

QR Code thus recovered from the frame can now be used to extract the data. There are several libraries that are capable and compatible with OpenCV such as ZBar.

Note: This step is not part of the sample.

Another useful library libdecoderqr that was demonstrated in earlier posts, can also be explored. Link

Source:

Git: https://github.com/bharathp666/opencv_qr.git

Download:
Download from DsynFLO box folder - https://app.box.com/s/191dc0l9hr37orltufok

License:
ZERO License.

References:

OpenCV 2D Image co-ordinate system - Link

OpenCV Contours

OpenCV Contour Member Elements

OpenCV Contour Hierarchy

Equation of a line - Link

Equation of a line with 2 known points -Link

Solutions to equation of a line - Link

Position of a point with respect to a straight line - Link
Perpendicular distance of point from a line formed by two other points - Link

Slope of a line - Link

O'REILLY Early Release Ebooks are now 50% off

2014-10-09T21:16:00.000-07:00

O'REILLY Early Release Ebooks are available now at 50% price until October 16 2014. So Hurry!!!

Shop: O'Reilly Online Store

Top Picks:

Effective Modern C++

42 Specific Ways to Improve Your Use of C++11 and C++14

By Scott Meyers

Publisher: O'Reilly Media

Release Date: July 2014

Pages: 320

http://shop.oreilly.com/product/0636920033707.do

Learning OpenCV

Computer Vision in C++ with the OpenCV Library

By Adrian Kaehler, Gary Bradski

Publisher: O'Reilly Media

Release Date: October 2013

Pages: 575

http://shop.oreilly.com/product/0636920022497.do

UX Strategy

How to Devise Innovative Digital Products that People Want

By Jaime Levy

Publisher: O'Reilly Media

Release Date: September 2014

Pages: 275

http://shop.oreilly.com/product/0636920032090.do

The Hardware Startup

Building Your Product, Business, and Brand

By Renee DiResta

Publisher: O'Reilly Media

Release Date: May 2014

Pages: 200

http://shop.oreilly.com/product/0636920030805.do

mono : Minimal Social Media Buttons

2014-09-05T06:54:00.003-07:00

Minimal Social Media Icons for Websites/Blogs/Profiles etc. The PSD file is customizable to suit any Social Media Network. Find the samle HTML code and PSD files within the package

Download:
Download from DsynFLO box folder - https://app.box.com/s/w71o522iuz0nwmk3zy0t
DeviantArt : mono : minimal social media icons by bharathp666 on deviantART

The Sample code below is the same used on this site. The Sample has on demand buttons for Google, Twitter, Facebook, Feedly* and Email using 'AddThis' customization. The code also features variation in color for mouse over event. Note: Code for 'Feedly' in the sample redirects to DsynFLO feeds. Don't forget to modify it before use.

More on 'AddThis': http://support.addthis.com/customer/portal/articles/381236-custom-buttons

Live Site : http://dsynflo.blogspot.com
HTML Demo : http://jsbin.com/mijusu/1/edit?html,output
Online hosting : https://picasaweb.google.com/106461262664551894489/Public

Sample Code:

<!-- HTML Code for mono: Social Media Icons by DsynFLO-- >

<!-- Google -->
<script type="text/javascript" src="//s7.addthis.com/js/300/addthis_widget.js"></script>
<a class='addthis_button_google_plusone_share'><img alt='Share on Google Plus' src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjwMQdwr4Qhl0PUg86vi2pqCks-I9mS7yx0TZIVNcY4y046TZh2A3FAGA6Gdc_68qCLPTEFJ2sE8yqn_AG27kcihO9BmKeUml7u3B0QHbKQIAnSS2lbocV5LrkVO0TrmLCDMDkKE8iI1oU/s800/google.png' 
onmouseover="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgZ3rsOB35BKZY6f8Qsqq-hJ6A52u-rtja1XKJgK74Ml8KuqSlkLk1ea68iA8kJVHn7Gn451HauY-1eQjBkPsYgeoMsyujZBYXD2ec_2OdtiA0Ti5ApwmqJ7xTI48s9G8s2gZtb6MwDLlE/s800/hgoogle.png'" 
onmouseout="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjwMQdwr4Qhl0PUg86vi2pqCks-I9mS7yx0TZIVNcY4y046TZh2A3FAGA6Gdc_68qCLPTEFJ2sE8yqn_AG27kcihO9BmKeUml7u3B0QHbKQIAnSS2lbocV5LrkVO0TrmLCDMDkKE8iI1oU/s800/google.png'" height='40px' width='40px' /></a>

<!-- Twitter -->
<a class='addthis_button_twitter'><img alt='Share on Twitter' src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg0_kiXlbWnHlBNpyXcE9w5wwA2zmHbTXnFWA4mfO0H2OPyZ22nRb7J-03F-sAXqAWMtHCYy8Sxua8G7iIq3ODmgSG6FwllC0N_C2I5Bw6ggjjb-kbK24gYvJLFPlyFiq8Y_eAZF8Lc-Oc/s800/twitter.png' 
onmouseover="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgS3a7vDB-EeB2oJklyfPYTDTjBbfe47KoP3mqxV_SXXOxSWb60VwsJtGmB9H3WMGfcXO1eWUfN_tRusNulRVs7Y2pEvkfdbT-xLkdCOwKiQmRMyqkvzDdlykpmvDpEqmY8ZEo-KPZeD2A/s800/htwitter.png'" 
onmouseout="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg0_kiXlbWnHlBNpyXcE9w5wwA2zmHbTXnFWA4mfO0H2OPyZ22nRb7J-03F-sAXqAWMtHCYy8Sxua8G7iIq3ODmgSG6FwllC0N_C2I5Bw6ggjjb-kbK24gYvJLFPlyFiq8Y_eAZF8Lc-Oc/s800/twitter.png'" height='40px' width='40px' /></a>

<!-- Facebook -->
<a class='addthis_button_facebook'><img alt='Share on Facebook' src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgXs69mkGlCaXfvFDsJ7Vn9xDvQdkRlKFMwtkpROj5UYXL69hqj9BOlojKBMdVDL0FqYcnG4I5Z1OY5DIgjmUaUQRlb7UwKOT4YXQ-pLupXOOkaIYIyxUQmz4vwCvQy83gOlzimtXD7t2M/s800/facebook.png' 
onmouseover="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjddDFacEiJnkGUU91fY725FyNdCUUfXZV5Y6J-waai60sX_Ya7Yz4iHy9Rz7dnWlPIyvxYDxFYIG71Xy9cpMck8EzyWFerkAfJBtOvBclUFdhdphu4w5ZSaqc0McLtI4yN0d3HsTA4kc8/s800/hfacebook.png'" 
onmouseout="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgXs69mkGlCaXfvFDsJ7Vn9xDvQdkRlKFMwtkpROj5UYXL69hqj9BOlojKBMdVDL0FqYcnG4I5Z1OY5DIgjmUaUQRlb7UwKOT4YXQ-pLupXOOkaIYIyxUQmz4vwCvQy83gOlzimtXD7t2M/s800/facebook.png'" height='40px' width='40px' /></a>

<!-- Feedly -->
<a href="http://cloud.feedly.com/#subscription%2Ffeed%2Fhttp%3A%2F%2Ffeeds.feedburner.com%2FDsynFLO" target="blank"><abbr title="Feedly"><img alt="Follow us in feedly" id="feedlyFollow" 
src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi_iqI-vaqLOOzMKmSDIcfreTGiE6BMR2Ppca0Tx1wFVWgQAmOISmaSeIK7g0F5jVHuC2_3uhrwP5aSDLhGDPD7bWf6tmdP4i2pFSeFH6pZmnzQ3RbyXyp3WM3iu5FDBdvJIfSf-e_5YO8/s800/feedly.png" 
onmouseover="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgsokjWkb4MOzu0TlnfI5ZbmJdxzMBY-TgXT0LXSCoqY6NoD9qRT3uHIv4CgyLwMEJ4KLZ_-tOSBkuGR1TQKnWXFOrRzLNrjt0krpKx52_5DUaV0Zdd8UbD-G6C3UAd5krNF4aJdbr4BwE/s800/hfeedly.png'" 
onmouseout="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi_iqI-vaqLOOzMKmSDIcfreTGiE6BMR2Ppca0Tx1wFVWgQAmOISmaSeIK7g0F5jVHuC2_3uhrwP5aSDLhGDPD7bWf6tmdP4i2pFSeFH6pZmnzQ3RbyXyp3WM3iu5FDBdvJIfSf-e_5YO8/s800/feedly.png'" height='40px' width='40px'  /></abbr></a>

<!-- Mail-->
<a class='addthis_button_email'><img alt='Share vai Email' src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhfhChR0yUCTj7poFbT5vuf8VJMraDB0fsX3Sk9fLUTn6hhlS-P77rhq15IopQCtzQr0XRiKXFyFF0tLH-LtmxLs2qCDsRLu0nhwhZfypDabGBSNQBBhAaj5A00pcaifCOO1UhO_zLZaH8/s800/mail2.png' 
onmouseover="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjljhypEz6Ifo1I0XAbfOIaRUVjUlCfTxy9dmmYNpkSOgPS0GiYSiUOIl0r3tJjIaGgbvTxQqYX6Df9HwjD8HKIRw5SXh5K7eFcnJCnezxOLFTobTpfU5rfeT0ODvNhQ8ZiuWt7rEUpeks/s800/hmail2.png'" 
onmouseout="this.src='https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhfhChR0yUCTj7poFbT5vuf8VJMraDB0fsX3Sk9fLUTn6hhlS-P77rhq15IopQCtzQr0XRiKXFyFF0tLH-LtmxLs2qCDsRLu0nhwhZfypDabGBSNQBBhAaj5A00pcaifCOO1UhO_zLZaH8/s800/mail2.png'" height='40px' width='40px'  /></a>

The Best Smart Watch ever made

2014-08-31T04:05:00.000-07:00

MOTO360 [Image from Mashable]

Watch becomes more than an accessory

Time keeping devices are nothing short of a modern marvel. Clocks were the first of devices to be acknowledged by a wide audience and recieve almost universal adoption. These devices were the genesis for all the revolutionary computing devices that we have today. By closing the physical distance and by radiating more personality, Watches embraced even more success. This is where the Watch becomes more than an accessory. By the end of this year we might probably witness a revival of the lost art of watch making. The more interesting aspect is that, this might as well trigger rapid advancements in the wearable market. Recent venturing of tech giants into this arena will and must herald future technical advances in wearable technology as well as personal healthcare.

PC HAS BEEN THE PRIMARY SOURCE FOR MAJORITY OF THE DIGITAL CONTENT

The PC has been the primary source for majority of the digital content. The Smart Phone has slowly but surely stepped up as an important entity of Data creation. Googles continued disconnection with PC world is due to the fact that Chrome OS hasn’t taken off anywhere nor does it play nice with any other platforms. Android never promised an enhanced experience for sharing content across Mobile devices and PCs. Instead, Googles persistence over faux unified experience with a hoard of “seamless” cloud apps has seen success at least to an extent. Google cloud apps are an affirmative addition to Android but never bridged what Ubuntu for Android tried to provide and possibly the OS X Yosemite-iOS ‘Continuity’ will.

SMART WATCH NEEDS AN INDEPENDENT IDENTITY

Click to enlarge

Look at where the Phone, meant to be used as a remote PC, ended up. The Smartwatch has to stop being a remote view of a remote view of a remot… You get the point. There is no need to tie down these watches to the Smart Phone. The Smart Watch needs an Independent Identity. It must serve the purpose it was built for. Keeping Time must be the fundamental idea around which the other features must converge.

YET ANOTHER VERSION OF ANDROID WAS NOT THE ANSWER WE NEEDED

It doesn’t seem bizarre when all Tech companies working on same ideas (may be different implementations) end up producing ~~same~~ similar products. It is not difficult to imagine someone rushing into Google’s office to announce “Apple is making an iWatch!!!” or the inverse at Apple’s office. There is a unanimous effort from the companies to push into Smart Watch business at full steam. Google’s former protégé Motorola and Android accomplice LG have dived first to bring out Android Wear Watches. Amongst them, Motorola’s MOTO360 is more beautiful and also seems to be the one worth buying. But I fear yet another version of android was not the answer we needed. There are as well alternate experiments happening in the market referring to likes of Samsung’s Tizen Watches, Sony Smartwatches, People-funded success story Pebble and then Apple’s wearable (iWatch?). Pebble has been excessively promoted in Social Media by Authors who are backing the Project or raising opinions since they own one or they are just simply assuming many are rooting to own one. The Pebble is a good product but not ‘the’ best product. It is arduously concentrated on being a remote notification device while leaving a huge gap in terms of appeal as a Watch. This is where Apple will come into its own. It appears as though it would provide what the current vendors will fail to provide – A Watch. It will be down on hardware specifications compared to existing market baseline but there is no doubt it will sell. Make no mistake I am a pro Android user but none of the devices from any manufacturer satiate my demands, and that is what I’m raving about in this article.

Introducing quantum Smart Watch concept

Click to enlarge

Before everybody goes bonkers over Apple’s new training kit and then others start off a bandwagon of watches, I want to show off what is possible. I want to set the tone for devices ahead, so I give you - “quantum”.

Key elements for the design

WATCH = TIME
‘Clean and Elegant’
‘Simple and Easy’
‘Precise and Timeless Presence'

Click to enlarge

Guidelines for building the Best Smart Watch

Visibility The perception of depth is the key to replace a practical device that visually interfaces a human body. Think 3D displays and/or Virtual/Augmented displays, Google Glass for instance.

Interoperability Smart Watch needs an Independent Identity. Think Sync-free ecosystem, Data connectivity only once a while or completely absent, Create content within device.

Mobility Anything with a wire is not a Wearable rather wire-enabled. Think solar charging, Wireless power, and Body heat conversion.

Capability There no need for a >400Mhz processor equipped device to be on your arm. Think OS-less device, purpose-built device and dedicated functions.

Durability The Materials must be adaptable to activities. Think Hard Metals bodies, Scratch resistant Glass, Durable straps, Water/Dust resistance.

Usability Create Time driven events rather than Content/Data driven events. Sync only when required.

Credibility Everybody, Please stop ‘Dick Tracy’ing around!!! Think of commendable applications such as NFC based Medical Information Card, Emergency contact or Emergency information, Buzz alerts for taking pills/keep drowsiness away while driving, Magnetic Compass for navigation, Gesture recognition , Non-invasive health monitoring.

Smart Watch Features Wish list

- AMOLED 3D display with Sapphire

- High Density Small Volume Battery

- Transparent Infrared Solar cells

- POWER over WIFI (new standard) Wireless Charging option

- WiFi Direct support

- Water resistance and Dust resistance

- NFC

- Accelerometer, Gyroscope, Digital Compass and Barometer

- Gesture Control for higher devices

Healthcare Features Wish list

- Geiger counter for Radiation sensing

- Pedometer

- In-contact Body temperature sensor and monitoring

- Infrared Heart rate sensor and monitoring

- Ultrasonic Blood pressure monitoring

- Non-invasive Blood sugar monitoring

- NFC assisted Global Medicare card with Emergency Distress Signals

Comparison Chart of Devices

	HTC Wildfire	Sony Liveview	Motorola MOTOACTV	LG G Watch
Launch	May 2010	Dec 2010	Dec 2011	July 2014
Processor Family	Qualcomm Snapdragon S1	STMicroelectronics 32 bit ARM MCU	TI OMAP 3	Qualcomm Snapdragon 400
Model	MSM7225	ST 32F103C6	OMAP3630-600	MSM 8226
CPU	ARM11	ARM Cortex-M3	ARM Cortex-A8	ARM Cortex-A7
Frequency	528 MHz	72 MHz	600 MHz	787 MHz
GPU	-	-	PowerVR SGX530	Adreno 305
Price	Rs 24000	Rs 9600	Rs 14950	Rs 15300

Unanswered Questions from the Article

Will Android Wear take off?

~~Will~~ When will phasing out of Chrome OS happen as Android TV/ Wear/Auto/@Home take flight?

Will existing companies involved in making specialty commodity play ball or perish?

Download:
Download from DsynFLO box folder - https://app.box.com/s/wjver8chwlxdz32s4lei

Fine Print

The information mentioned here are purely the perceptions of the Author and are not from any data analysis study or information data source. They are only opinions expressed by the Author. Android, Apple, Braun, HTC, Google, LG, Microsoft, Motorola, Qualcomm, Sony and Obaku are registered trademarks of respective entities. Names are used only for Illustration. DsynFLO or the Author do not have any affiliations with these entities or vice versa.

simplAR 2: 99 Lines of Code for Augmented Reality with OpenCV using Chessboard

2014-08-15T05:50:00.001-07:00

This is a simple program that implements Augmented Reality in OpenCV. This is a follow-up for the previous post that was implemented in the old 1.0 API.

Files:
Download from DsynFLO box folder - https://app.box.com/s/nh82nmjt2w3fxj85g399

Usage:

cmake .
make
./app

Overlay Image:
Photo by Bharath P. Zero License.

Pattern:

Source:

//______________________________________________________________________________________
// Program : SimplAR 2 - OpenCV Simple Augmented Reality Program with Chessboard
// Author  : Bharath Prabhuswamy
//______________________________________________________________________________________

#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

#define CHESSBOARD_WIDTH 6
#define CHESSBOARD_HEIGHT 5
//The pattern actually has 6 x 5 squares, but has 5 x 4 = 20 'ENCLOSED' corners

int main ( int argc, char **argv )
{

 Mat img;
 Mat display = imread("shingani.jpg");
 VideoCapture capture(0);

 Size board_size(CHESSBOARD_WIDTH-1, CHESSBOARD_HEIGHT-1);
    
 vector<Point2f> corners;

 if(display.empty())
 {
  cerr << "ERR: Unable to find overlay image.\n" << endl;
  return -1;
 }
 
 if ( !capture.isOpened() )
 {
  cerr << "ERR: Unable to capture frames from device 0" << endl;
  return -1;
 }
    
    int key = 0;
 
 while(key!='q')
 {
  // Query for a frame from Capture device
  capture >> img;

  Mat cpy_img(img.rows, img.cols, img.type());
  Mat neg_img(img.rows, img.cols, img.type());
  Mat gray;
  Mat blank(display.rows, display.cols, display.type());

        cvtColor(img, gray, CV_BGR2GRAY);
        
  bool flag = findChessboardCorners(img, board_size, corners);

  if(flag == 1)
  {            
   // This function identifies the chessboard pattern from the gray image, saves the valid group of corners
   cornerSubPix(gray, corners, Size(11,11), Size(-1,-1), TermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1));
    
   vector<Point2f> src;   // Source Points basically the 4 end co-ordinates of the overlay image
   vector<Point2f> dst;   // Destination Points to transform overlay image 
   
   src.push_back(Point2f(0,0));
   src.push_back(Point2f(display.cols,0));
   src.push_back(Point2f(display.cols, display.rows));
   src.push_back(Point2f(0, display.rows));
 
   dst.push_back(corners[0]);
   dst.push_back(corners[CHESSBOARD_WIDTH-2]);
   dst.push_back(corners[(CHESSBOARD_WIDTH-1)*(CHESSBOARD_HEIGHT-1)-1]);
   dst.push_back(corners[(CHESSBOARD_WIDTH-1)*(CHESSBOARD_HEIGHT-2)]);
 
   // Compute the transformation matrix, 
   // i.e., transformation required to overlay the display image from 'src' points to 'dst' points on the image
   Mat warp_matrix = getPerspectiveTransform(src, dst);

   blank = Scalar(0);
   neg_img = Scalar(0);        // Image is white when pixel values are zero
   cpy_img = Scalar(0);        // Image is white when pixel values are zero

   bitwise_not(blank,blank);

   // Note the jugglery to augment due to OpenCV's limitation passing two images of DIFFERENT sizes while using "cvWarpPerspective"

   warpPerspective(display, neg_img, warp_matrix, Size(neg_img.cols, neg_img.rows)); // Transform overlay Image to the position - [ITEM1]
   warpPerspective(blank, cpy_img, warp_matrix, Size(cpy_img.cols, neg_img.rows));  // Transform a blank overlay image to position 
   bitwise_not(cpy_img, cpy_img);       // Invert the copy paper image from white to black
   bitwise_and(cpy_img, img, cpy_img);      // Create a "hole" in the Image to create a "clipping" mask - [ITEM2]      
   bitwise_or(cpy_img, neg_img, img);      // Finally merge both items [ITEM1 & ITEM2]
 
  }

  imshow("Camera", img);
  key = cvWaitKey(1); 
 }
    
 destroyAllWindows();
 return 0;
}

OpenAR: OpenCV Augmented Reality Program

2014-08-10T00:42:00.001-07:00

OpenAR is a very simple C++ implementation to achieve Marker based Augmented Reality. OpenAR based on OpenCV and solely dependent on the library. OpenAR decodes markers in a frame of image. OpenAR does not implement Marker tracking across frames. Also OpenAR does not implement Template matching for Marker decoding.

Demo:

Building up to openAR:
Some of the basic operations are independently discussed in the previous posts -
Link Installing Ubuntu 14.04
Link Installing OpenCV 2.4.9 in Ubuntu
Link Building a simple OpenCV Program
Link OTSU thresholding
Link Corner Detection
Link Connected Component extraction

Source:
Git: https://github.com/bharathp666/openAR

Download:
Download from DsynFLO box folder - https://app.box.com/s/p2cpo7i6vp9ilazk3dhv

Instructions:

cmake .
make
./openar

License:
ZERO License. Students, Geeks, Tramps alike, free for all. :)

Implementation Notes:

1. The program picks up one blob at a time and does not release it until it is verified if it is the marker. This method is chosen to eliminate creation of yet an another array containing details of all blobs of the image.

2. Tracking the marker in subsequent frames is not implemented to keep the program simple and understandable. (It was too complicated for me as well!)

3. Augmentation jugglery

Tuning the code:
If you are facing issues to reliably detect Markers, the following can be done -
1. Decrease the severity to determine corners. Warning: Segmentation fault (read next section)
2. Decrease the severity on blob size constraints.

Limitations:
1. Possible Segmentation fault due to too many corners and hence the array of corners may overflow.
2. Rotation of image according to the pattern orientation is not taken care but it can be done easily.
3. Detection fails on blurry images caused by rapid movement of markers.

Further enhancements:
Interested contributors fork me at Github or Mail me -
[ ] Code movement from legacy OpenCV 1.0 to 2.4.9
[ ] OpenGL integration - if required or may be OpenCV 3D visualization (3.0+)
[ ] Create an OpenAR library

Support:

For most parts- it must work. In case you hit a problem you can comment below or mail me, I would be glad to help. I'm not a seasoned C++ programmer and for any advanced assistance; posting a question at stackoverflow.com under 'opencv' tag is recommended.

References and Further reading:

1. [Book] Learning OpenCV - Computer Vision with the OpenCV Library

By Gary Bradski, Adrian Kaehler

First Edition

http://shop.oreilly.com/product/9780596516130.do

2. ARlib – C++ Augmented reality library

by Danny Diggins

3. Features from accelerated segment test

by Edward Rosten

http://www.edwardrosten.com/work/fast.html

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

4. Connected Components Analysis

http://en.wikipedia.org/wiki/Connected-component_labeling

http://homepages.inf.ed.ac.uk/rbf/HIPR2/label.htm

5. Perpendicular Distance of a Point from a line

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

http://www.intmath.com/plane-analytic-geometry/perpendicular-distance-point-line.php

6. Solutions to Equation of a Line

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

http://doubleroot.in/straight-line-position-of-a-point-relative-to-a-line-examples/#

http://www.emathzone.com/tutorials/geometry/position-of-point-with-respect-to-line.html

OpenCV Online Resources:

http://www.seas.upenn.edu/~bensapp/opencvdocs/ref/opencvref_cv.htm

If you like my work - Please share !!!

OpenCV: Connected Component Analysis

2014-08-03T06:41:00.000-07:00

Image - License_plate_Tirana.JPG

Public Domain | Link

A lot of openCV based programs depend on blob detection for extracting region of interest for post processing. There are numerous blob identification libraries such as cvblob , cvbloblib and the newer opencvblob.

The code below is a slightly different algorithm that detects connected components from the Image. The key to understanding this algorithm is to know the inheritance, relation and state of the pixels surrounding each other.
To analyze the image, first we start off running through one scan line at a time. As soon as a black pixel is encountered, it is the treated as the start of the blob. If the next pixel in the scan line is also black than the scanning continues else the program jumps to next scan line. Also when the first black pixel of the scan line is determined, a check is made if the next scan line has a black pixel below it. If it is present then it indicates the there is continuation of the blob in the next scan line. So the vertical inheritance is flagged and the program continues to progress in the scan line. When the program reaches to the next scan line, it checks if the black pixel has veritcal inheritence, if yes then it is part of the current blob that is being scanned.

A Matrix (in the form of IPlImage) called Process_Flag is maintained to make sure a black pixel encountered is flagged as analyzed for further scanning. This way one black pixel part of a particular blob doesn't get added again as part of another blob.

Note that majority of the "if-else" conditions in the code is to handle traversing through the inheritance. Also the pixel count of the blob and 2 points giving the span of the blob is recorded and updated on the fly while scanning.

Try out the program on a still image to study the various detection capabilities of the program. Additional training images are available in the shared link

Tweaking the code:

The program can be tweaked to reduce or minimize unwanted blobs that contain only 3 or 4 pixels or is 1 pixel wide and 100 pixel long. To remove such blobs, you can filter using the count of pixels in each blob. Also we already store the start and end points of each blob that gives us the span of the blob. By calculating the aspect ratio of the blob and the number of pixels in each blob - we can eliminate irrelevant blobs.

The image below depicts the decision making -

Example code snippet that allows all blobs to be seen

rectw = abs(cornerA.x - cornerB.x);
recth = abs(cornerA.y - cornerB.y);
aspect_ratio = (double)rectw / (double)recth;

if(n > 20)
{
 if(aspect_ratio > 0) 
 {

Now change this to -

int min_blob_sze = 400;               // Minimum Blob size limit 
int max_blob_sze = 150000;            // Maximum Blob size limit

rectw = abs(cornerA.x - cornerB.x);
recth = abs(cornerA.y - cornerB.y);
aspect_ratio = (double)rectw / (double)recth;
if((n > min_blob_sze) && (n < max_blob_sze))  // Reduces chances of decoding erroneous 'Blobs' as markers
{
 if((aspect_ratio > 0.33) && (aspect_ratio < 3.0)) // Increases chances of identified 'Blobs' to be close to Square 
 {

Notice the difference between the two images -

Usage:

cmake .
make

# For detecting blobs from camera frames
./video
# For detecting blobs in a still image
./still <image.jpg>

Files:
Download from DsynFLO box folder -
Source - https://app.box.com/s/r42ua57wco3z3h00j4wt
Training Images - https://app.box.com/s/d1zj7l5d9qja8kvod55x

Compatibility > OpenCV 1.0

Source Code :

//______________________________________________________________________________________
// Program : OpenCV connected component analysis
// Author  : Bharath Prabhuswamy
//______________________________________________________________________________________
#include <cv.h>
#include <highgui.h>
#include <math.h>
#include <stdio.h>
#include <string.h>

void cv_adjustBox(int x, int y, CvPoint& A, CvPoint& B);  // Routine to update Bounding Box corners

// Start of Main Loop
//------------------------------------------------------------------------------------------------------------------------
int main ( int argc, char **argv )
{
 CvCapture* capture = 0;
 IplImage* img = 0;

 capture = cvCaptureFromCAM( 0 );
  if ( !capture )                // Check for Camera capture
  return -1;

 cvNamedWindow("Camera",CV_WINDOW_AUTOSIZE);

 //cvNamedWindow("Threshold",CV_WINDOW_AUTOSIZE);

 // cvNamedWindow("Test",CV_WINDOW_AUTOSIZE); // Test window to push any visuals during debugging

 IplImage* gray = 0;
 IplImage* thres = 0;
 IplImage* prcs_flg = 0;     // Process flag to flag whether the current pixel is already processed as part blob detection


 int q,i;        // Intermidiate variables
 int h,w;        // Variables to store Image Height and Width

 int ihist[256];                      // Array to store Histogram values
 float hist_val[256];     // Array to store Normalised Histogram values

 int blob_count;
 int n;                                 // Number of pixels in a blob
 int pos ;        // Position or pixel value of the image

 int rectw,recth;                     // Width and Height of the Bounding Box
 double aspect_ratio;      // Aspect Ratio of the Bounding Box

 int min_blob_sze = 400;               // Minimum Blob size limit 
 int max_blob_sze = 150000;            // Maximum Blob size limit


 bool init = false;      // Flag to identify initialization of Image objects


 //Step : Capture a frame from Camera for creating and initializing manipulation variables
 //Info : Inbuit functions from OpenCV
 //Note : 

     if(init == false)
 {
         img = cvQueryFrame( capture ); // Query for the frame
          if( !img )  // Exit if camera frame is not obtained
   return -1;

  // Creation of Intermediate 'Image' Objects required later
  gray = cvCreateImage( cvGetSize(img), 8, 1 );  // To hold Grayscale Image
  thres = cvCreateImage( cvGetSize(img), 8, 1 );  // To hold OTSU thresholded Image
  prcs_flg = cvCreateImage( cvGetSize(img), 8, 1 ); // To hold Map of 'per Pixel' Flag to keep track while identifing Blobs
  
  init = true;
 }

 int clr_flg[img->width];  // Array representing elements of entire current row to assign Blob number
 int clrprev_flg[img->width]; // Array representing elements of entire previous row to assign Blob number

 h = img->height;  // Height and width of the Image
 w = img->width;

 int key = 0;
 while(key != 'q')  // While loop to query for Camera frame
 {
    
  //Step : Capture Image from Camera
  //Info : Inbuit function from OpenCV
  //Note : 

  img = cvQueryFrame( capture );  // Query for the frame

  //Step : Convert Image captured from Camera to GrayScale
  //Info : Inbuit function from OpenCV
  //Note : Image from Camera and Grayscale are held using seperate "IplImage" objects

  cvCvtColor(img,gray,CV_RGB2GRAY); // Convert RGB image to Gray


  //Step : Threshold the image using optimum Threshold value obtained from OTSU method
  //Info : 
  //Note : 

  memset(ihist, 0, 256);

  for(int j = 0; j < gray->height; ++j) // Use Histogram values from Gray image
  {
   uchar* hist = (uchar*) (gray->imageData + j * gray->widthStep);
   for(int i = 0; i < gray->width; i++ )
   {
    pos = hist[i];  // Check the pixel value
    ihist[pos] += 1; // Use the pixel value as the position/"Weight"
   }
  }

  //Parameters required to calculate threshold using OTSU Method
  float prbn = 0.0;                   // First order cumulative
  float meanitr = 0.0;                // Second order cumulative
  float meanglb = 0.0;                // Global mean level
  int OPT_THRESH_VAL = 0;             // Optimum threshold value
  float param1,param2;                // Parameters required to work out OTSU threshold algorithm
  double param3 = 0.0;

  //Normalise histogram values and calculate global mean level
  for(int i = 0; i < 256; ++i)
  {
   hist_val[i] = ihist[i] / (float)(w * h);
   meanglb += ((float)i * hist_val[i]);
  }

      // Implementation of OTSU algorithm
  for (int i = 0; i < 255; i++)
  {
   prbn += (float)hist_val[i];
   meanitr += ((float)i * hist_val[i]);

   param1 = (float)((meanglb * prbn) - meanitr);
   param2 = (float)(param1 * param1) /(float) ( prbn * (1.0f - prbn) );

   if (param2 > param3)
   {
       param3 = param2;
       OPT_THRESH_VAL = i;     // Update the "Weight/Value" as Optimum Threshold value
   }
  }

  cvThreshold(gray,thres,OPT_THRESH_VAL,255,CV_THRESH_BINARY); //Threshold the Image using the value obtained from OTSU method


  //Step : Identify Blobs in the OTSU Thresholded Image
  //Info : Custom Algorithm to Identify blobs
  //Note : This is a complicated method. Better refer the presentation, documentation or the Demo

  blob_count = 0;    // Current Blob number used to represent the Blob
  CvPoint cornerA,cornerB;  // Two Corners to represent Bounding Box

  memset(clr_flg, 0, w);  // Reset all the array elements ; Flag for tracking progress
  memset(clrprev_flg, 0, w);

  cvZero(prcs_flg);   // Reset all Process flags


        for( int y = 0; y < thres->height; ++y) //Start full scan of the image by incrementing y
        {
            uchar* prsnt = (uchar*) (thres->imageData + y * thres->widthStep);
            uchar* pntr_flg = (uchar*) (prcs_flg->imageData + y * prcs_flg->widthStep);  // pointer to access the present value of pixel in Process flag
   uchar* scn_prsnt;      // pointer to access the present value of pixel related to a particular blob
   uchar* scn_next;       // pointer to access the next value of pixel related to a particular blob

            for(int x = 0; x < thres->width; ++x ) //Start full scan of the image by incrementing x
            {
                int c = 0;     // Number of edgels in a particular blob
               
                if((prsnt[x] == 0) && (pntr_flg [x] == 0)) // If current pixel is black and has not been scanned before - continue
                {
   blob_count +=1;                          // Increment at the start of processing new blob
   clr_flg [x] = blob_count;                // Update blob number
   pntr_flg [x] = 255;                      // Mark the process flag

   n = 1;                                   // Update pixel count of this particular blob / this iteration

   cornerA.x = x;                           // Update Bounding Box Location for this particular blob / this iteration
   cornerA.y = y;
   cornerB.x = x;
   cornerB.y = y;

   int lx,ly;    // Temp location to store the initial position of the blob
   int belowx = 0;

   bool checkbelow = true;   // Scan the below row to check the continuity of the blob

                    ly=y;

                    bool below_init = 1;     // Flags to facilitate the scanning of the entire blob once
                    bool start = 1;

                        while(ly < h)      // Start the scanning of the blob
                        {
                            if(checkbelow == true)   // If there is continuity of the blob in the next row & checkbelow is set; continue to scan next row
                            {
                                if(below_init == 1)   // Make a copy of Scanner pixel position once / initially
                                {
                                    belowx=x;
                                    below_init = 0;
                                }

                                checkbelow = false;  // Clear flag before next flag

                                scn_prsnt = (uchar*) (thres->imageData + ly * thres->widthStep);
                                scn_next = (uchar*) (thres->imageData + (ly+1) * thres->widthStep);

                                pntr_flg = (uchar*) (prcs_flg->imageData + ly * prcs_flg->widthStep);

                                bool onceb = 1;   // Flag to set and check blbo continuity for next row

                                //Loop to move Scanner pixel to the extreme left pixel of the blob
                                while((scn_prsnt[belowx-1] == 0) && ((belowx-1) > 0) && (pntr_flg[belowx-1]== 0))
                                {
                                    cv_adjustBox(belowx,ly,cornerA,cornerB);    // Update Bounding Box corners
                                    pntr_flg [belowx] = 255;

                                    clr_flg [belowx] = blob_count;

                                    n = n+1;
                                    belowx--;
                                }
                                //Scanning of a particular row of the blob
                                for(lx = belowx; lx < thres->width; ++lx )
                                {
                                    if(start == 1)                  // Initial/first row scan
                                    {
                                        cv_adjustBox(lx,ly,cornerA,cornerB);
                                        pntr_flg [lx] = 255;

                                        clr_flg [lx] = blob_count;


                                        start = 0;
                                        if((onceb == 1) && (scn_next[lx] == 0))                 //Check for the continuity
                                        {
                                            belowx = lx;
                                            checkbelow = true;
                                            onceb = 0;
                                        }
                                    }
                                    else if((scn_prsnt[lx] == 0) && (pntr_flg[lx] == 0))               //Present pixel is black and has not been processed
                                    {
                                        if((clr_flg[lx-1] == blob_count) || (clr_flg[lx+1] == blob_count)) //Check for the continuity with previous scanned data
                                        {
                                            cv_adjustBox(lx,ly,cornerA,cornerB);

                                            pntr_flg [lx] = 255;

                                            clr_flg [lx] = blob_count;

                                            n = n+1;

                                            if((onceb == 1) && (scn_next[lx] == 0))
                                            {
                                                belowx = lx;
                                                checkbelow = true;
                                                onceb = 0;
                                            }
                                        }
                                        else if((scn_prsnt[lx] == 0) && (clr_flg[lx-2] == blob_count))  // Check for the continuity with previous scanned data
                                        {
                                            cv_adjustBox(lx,ly,cornerA,cornerB);

                                            pntr_flg [lx] = 255;

                                            clr_flg [lx] = blob_count;

                                            n = n+1;

                                            if((onceb == 1) && (scn_next[lx] == 0))
                                            {
                                                belowx = lx;
                                                checkbelow = true;
                                                onceb = 0;
                                            }
                                        }
                                        // Check for the continuity with previous scanned data
                                        else if((scn_prsnt[lx] == 0) && ((clrprev_flg[lx-1] == blob_count) || (clrprev_flg[lx] == blob_count) || (clrprev_flg[lx+1] == blob_count)))
                                        {
                                            cv_adjustBox(lx,ly,cornerA,cornerB);

                                            pntr_flg [lx] = 255;

                                            clr_flg [lx] = blob_count;

                                            n = n+1;

                                            if((onceb == 1) && (scn_next[lx] == 0))
                                            {
                                                belowx = lx;
                                                checkbelow = true;
                                                onceb = 0;
                                            }

                                        }
                                        else
                                        {
                                            continue;
                                        }

                                    }
                                    else
                                    {
                                        clr_flg[lx] = 0; // Current pixel is not a part of any blob
                                    }
                                } // End of scanning of a particular row of the blob
                            }
                            else // If there is no continuity of the blob in the next row break from blob scan loop
                            {
                                break;
                            }

                            for(int q = 0; q < thres->width; ++q) // Blob numbers of current row becomes Blob number of previous row for the next iteration of "row scan" for this particular blob
                            {
                                clrprev_flg[q]= clr_flg[q];
                            }
                            ly++;
                        }
                        // End of the Blob scanning routine 


   // At this point after scanning image data, A blob (or 'connected component') is obtained. We use this Blob for further analysis to confirm it is a Marker.

   
   // Get the Rectangular extent of the blob. This is used to estimate the span of the blob
   // If it too small, say only few pixels, it is too good to be true that it is a Marker. Thus reducing erroneous decoding
   rectw = abs(cornerA.x - cornerB.x);
   recth = abs(cornerA.y - cornerB.y);
   aspect_ratio = (double)rectw / (double)recth;

                        if((n > min_blob_sze) && (n < max_blob_sze))  // Reduces chances of decoding erroneous 'Blobs' as markers
                        {
                            if((aspect_ratio > 0.33) && (aspect_ratio < 3.0)) // Increases chances of identified 'Blobs' to be close to Square 
                            {
                                // Good Blob; Mark it
        cvRectangle(img,cornerA,cornerB,CV_RGB(255,0,0),1);
                            } 
                            else // Discard the blob data
                            {                      
                                blob_count = blob_count -1; 
                            }
                        }
                        else    // Discard the blob data               
                        {
                            blob_count = blob_count -1;  
                        }

                }
                else     // If current pixel is not black do nothing
                {
                    continue;
                }
  } // End full scan of the image by incrementing x
        } // End full scan of the image by incrementing y
 

  cvShowImage("Camera",img);
  key = cvWaitKey(1); // OPENCV: wait for 1ms before accessing next frame

 } // End of 'while' loop

 cvDestroyWindow( "Camera" ); // Release various parameters

 cvReleaseImage(&img);
 cvReleaseImage(&gray);
 cvReleaseImage(&thres);
 cvReleaseImage(&prcs_flg);

     return 0;
}
// End of Main Loop
//------------------------------------------------------------------------------------------------------------------------


// Routines used in Main loops

// Routine to update Bounding Box corners with farthest corners in that Box
void cv_adjustBox(int x, int y, CvPoint& A, CvPoint& B)
{
    if(x < A.x)
        A.x = x;

    if(y < A.y)
        A.y = y;

    if(x > B.x)
        B.x = x;

    if(y > B.y)
        B.y = y;
}

// EOF

OpenCV: 'FAST' like Corner detection with scanning window

2014-07-26T10:30:00.000-07:00

The key to building many important OpenCV application, is to extract robust features from the image.
Depending on the application we tend to extract features such as corners, haar cascades, contours etc in both spatial and/or temporal dimensions.
The code here was initially implemented using OpenCV 1.0, the code works with latest version (2.4.9) as well.

The program basically checks the neighboring pixels lying on a 'Window' around the pixel under test. Consider a sample image thresholded and is under process. The Pixel A as we see from the image below contains optimum number of 'Black Pixels' in the Scanning Window - 5 in total. Whereas Pixels B and C have 3 and 10 respectively. Based on the Window size and a series of tests and inspection we can safely assume that A is a corner while B and C are not. So depending on the Window size and Optimal number if Black or White pixels around the pixel under test, we can mark them as corners.

The Image below is a representative of the code that has been implemented.

Notice that in the same code below, the number of 'Black Pixels' are being counted.
Also try and experiment by changing

 if((sum > 2 ) && (sum < 5))

 if((sum >= 8 ) && (sum < 9))

 if((sum >= 10 ) && (sum <= 11))

Note: FAST has been ported to OpenCV. It is available natively in OpenCV.
http://docs.opencv.org/modules/features2d/doc/feature_detection_and_description.html#fast

Compatibility > OpenCV 1.0

Files:
Download from DsynFLO box folder - https://app.box.com/s/h49lu1ht6mjbapym726z

Source Code:

//______________________________________________________________________________________
// Program : Corner Detection using OpenCV
// Author  : Bharath Prabhuswamy
//______________________________________________________________________________________
#include <cv.h>
#include <highgui.h>
#include <stdio.h>

bool find_corner(char* img_data,int img_width,int x,int y); // Routine to check whether a particular pixel is an Edgel or not

// Start of Main Loop
//------------------------------------------------------------------------------------------------------------------------
int main()
{
 CvCapture* capture = 0;
 IplImage* img = 0;
 //IplImage* img = cvLoadImage("test3.jpg"); // for still image

 capture = cvCaptureFromCAM( 0 );
  if ( !capture )             // Check for Camera capture
  return -1;
 
 cvNamedWindow("Camera",CV_WINDOW_AUTOSIZE);

 IplImage* gray = 0;
 IplImage* thres = 0;

 bool init = false;   // Flag to identify initialization of Image objects

     if(init == false)
 {
  img = cvQueryFrame( capture ); // Query for the frame

         if( !img )   // Exit if camera frame is not obtained
   return -1;

  // Creation of Intermediate 'Image' Objects required later
  gray = cvCreateImage( cvGetSize(img), 8, 1 );  // To hold Grayscale Image
  thres = cvCreateImage( cvGetSize(img), 8, 1 );  // To hold OTSU thresholded Image
 
  init = true;
 }

   
 int ihist[256];              // Array to store Histogram values
 float hist_val[256];  // Array to store Normalised Histogram values
 int pos ;   // Position or pixel value of the image
 float prbn;                    // First order cumulative
 float meanitr;                 // Second order cumulative
 float meanglb;   // Global mean level
 int OPT_THRESH_VAL;             // Optimum threshold value
 float param1,param2;            // Parameters required to work out OTSU threshold algorithm
 double param3;
 int h,w;   // Variables to store Image Height and Width
 
 h = img->height;  // Height and width of the Image
 w = img->width;

 CvPoint corner;
 bool corner_flag;

 int key = 0;
 while(key != 'q')
 {

  //Step : Capture Image from Camera
  //Info : Inbuit function from OpenCV
  //Note : 

  img = cvQueryFrame( capture );  // Query for the frame

  //Step : Convert Image captured from Camera to GrayScale
  //Info : Inbuit function from OpenCV
  //Note : Image from Camera and Grayscale are held using seperate "IplImage" objects

  cvCvtColor(img,gray,CV_RGB2GRAY); // Convert RGB image to Gray


  //Step : Threshold the image using optimum Threshold value obtained from OTSU method
  //Info : 
  //Note : 

  memset(ihist, 0, 256);

  for(int j = 0; j < gray->height; ++j) // Use Histogram values from Gray image
  {
   uchar* hist = (uchar*) (gray->imageData + j * gray->widthStep);
   for(int i = 0; i < gray->width; i++ )
   {
    pos = hist[i];  // Check the pixel value
    ihist[pos] += 1; // Use the pixel value as the position/"Weight"
   }
  }

  //Parameters required to calculate threshold using OTSU Method
  prbn = 0.0;                   // First order cumulative
  meanitr = 0.0;                // Second order cumulative
  meanglb = 0.0;                // Global mean level
  OPT_THRESH_VAL = 0;           // Optimum threshold value
  param1,param2;                // Parameters required to work out OTSU threshold algorithm
  param3 = 0.0;

  //Normalise histogram values and calculate global mean level
  for(int i = 0; i < 256; ++i)
  {
   hist_val[i] = ihist[i] / (float)(w * h);
   meanglb += ((float)i * hist_val[i]);
  }

  // Implementation of OTSU algorithm
  for (int i = 0; i < 255; i++)
  {
   prbn += (float)hist_val[i];
   meanitr += ((float)i * hist_val[i]);

   param1 = (float)((meanglb * prbn) - meanitr);
   param2 = (float)(param1 * param1) /(float) ( prbn * (1.0f - prbn) );

   if (param2 > param3)
   {
       param3 = param2;
       OPT_THRESH_VAL = i;     // Update the "Weight/Value" as Optimum Threshold value
   }
  }

  cvThreshold(gray,thres,OPT_THRESH_VAL,255,CV_THRESH_BINARY); //Threshold the Image using the value obtained from OTSU method

  int c = 0; 

  for( int y = 0; y < thres->height; ++y)  //Start full scan of the image by incrementing y
  {

   for(int x = 0; x < thres->width; ++x ) //Start full scan of the image by incrementing x
       {
        // Number of edgels in a particular blob
    corner_flag = find_corner(thres->imageData,thres->widthStep,x,y);
    if(corner_flag == true)  // Check for the Edgel and update Edgel storage
    {
     c++;
     corner.x = x;
     corner.y = y;
     cvCircle(img,corner,1,CV_RGB(255,0,0),1,8);

     corner_flag = false;
    }
   }
          
  }

  cvShowImage( "Camera",img);

  key = cvWaitKey(1); // OPENCV: wait for 1ms before accessing next frame
  //key = cvWaitKey(50000); // for still image

 } // End of while loop

 cvDestroyWindow( "Camera" ); // Release various parameters
 cvReleaseImage(&img);
 cvReleaseImage(&gray);
 cvReleaseImage(&thres);

     return 0;
}
// End of Main Loop
//------------------------------------------------------------------------------------------------------------------------


// Routine to check whether a particular pixel is an Edgel or not
bool find_corner(char* img_data,int img_width,int x,int y)
{ 
 const int wind_sz = 5 ;
 int wind_bnd = (wind_sz - 1) / 2;
 int sum = 0;
 bool result = false;
 uchar* ptr[wind_sz];
 int index =0;

 for(int k = (0-wind_bnd); k <= wind_bnd; ++k)
 {
   ptr[index] = (uchar*)(img_data + (y + k) *  img_width);
   index = index + 1 ;
 }

 for(int i = 0; i <= (wind_sz-1); ++i)
 {
  if((i == 0) || (i==(wind_sz-1)))
  {
      for (int j = (0-wind_bnd); j <= wind_bnd; ++j)
      {
   if(ptr[i][x+j] == 0)
      sum += 1;
   else
      continue;
      }
  }
  else
  {
      if(ptr[i][x-wind_bnd] == 0)
   sum += 1;
      else
   continue;

      if(ptr[i][x+wind_bnd] == 0)
   sum += 1;
      else
   continue;
  }
 }

    if((sum > 2 ) && (sum < 5))
    {
        result = true;
    }
    return result;
}
// EOF

OpenCV: Implementation of Threshold by OTSU method

2014-07-26T10:29:00.001-07:00

Here is a simple example showing implementation of OTSU thresholding in OpenCV.

Note: OTSU threshold available in OpenCV via the function threshold() and by using the pre-defined operand THRESH_OTSU
http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#threshold

Compatibility > OpenCV 1.0

Files:
Download from DsynFLO box folder - https://app.box.com/s/zzpm5yawbkin5fdbqutl

Source Code:

//______________________________________________________________________________________
// Program : OpenCV Otsu Thresholding
// Author  : Bharath Prabhuswamy
//______________________________________________________________________________________

#include <cv.h>
#include <highgui.h>
#include <stdio.h>

int main ( int argc, char **argv )
{
 CvCapture* capture = 0;
 IplImage* img = 0;

 capture = cvCaptureFromCAM( 0 );
 if ( !capture )            // Check for Camera capture
  return -1;

 cvNamedWindow("Camera",CV_WINDOW_AUTOSIZE);
 cvNamedWindow("Threshold",CV_WINDOW_AUTOSIZE);

 IplImage* gray = 0;
 IplImage* thres = 0;
 
 bool init = false;   // Flag to identify initialization of Image objects

     if(init == false)
 {
  img = cvQueryFrame( capture ); // Query for the frame

         if( !img )   // Exit if camera frame is not obtained
   return -1;

  // Creation of Intermediate 'Image' Objects required later
  gray = cvCreateImage( cvGetSize(img), 8, 1 );  // To hold Grayscale Image
  thres = cvCreateImage( cvGetSize(img), 8, 1 );  // To hold OTSU thresholded Image

  init = true;
 }

   
 int ihist[256];   // Array to store Histogram values
 float hist_val[256];  // Array to store Normalised Histogram values
 int pos ;   // Position or pixel value of the image
 float prbn;   // First order cumulative
 float meanitr;   // Second order cumulative
 float meanglb;   // Global mean level
 int OPT_THRESH_VAL;             // Optimum threshold value
 float param1,param2;  // Parameters required to work out OTSU threshold algorithm
 double param3;
 int h,w;   // Variables to store Image Height and Width
 
 h = img->height;  // Height and width of the Image
 w = img->width;

 int key = 0;
 while(key != 'q')
 {

  //Step : Capture Image from Camera
  //Info : Inbuit function from OpenCV
  //Note : 

  img = cvQueryFrame( capture ); // Query for the frame

  //Step : Convert Image captured from Camera to GrayScale
  //Info : Inbuit function from OpenCV
  //Note : Image from Camera and Grayscale are held using seperate "IplImage" objects

  cvCvtColor(img,gray,CV_RGB2GRAY); // Convert RGB image to Gray


  //Step : Threshold the image using optimum Threshold value obtained from OTSU method
  //Info : 
  //Note : 

  memset(ihist, 0, 256);

  for(int j = 0; j < gray->height; ++j) // Use Histogram values from Gray image
  {
   uchar* hist = (uchar*) (gray->imageData + j * gray->widthStep);
   for(int i = 0; i < gray->width; i++ )
   {
    pos = hist[i];  // Check the pixel value
    ihist[pos] += 1; // Use the pixel value as the position/"Weight"
   }
  }

  //Parameters required to calculate threshold using OTSU Method
  prbn = 0.0;                   // First order cumulative
  meanitr = 0.0;                // Second order cumulative
  meanglb = 0.0;                // Global mean level
  OPT_THRESH_VAL = 0;           // Optimum threshold value
  param1,param2;                // Parameters required to work out OTSU threshold algorithm
  param3 = 0.0;

  //Normalise histogram values and calculate global mean level
  for(int i = 0; i < 256; ++i)
  {
   hist_val[i] = ihist[i] / (float)(w * h);
   meanglb += ((float)i * hist_val[i]);
  }

  // Implementation of OTSU algorithm
  for (int i = 0; i < 255; i++)
  {
   prbn += (float)hist_val[i];
   meanitr += ((float)i * hist_val[i]);

   param1 = (float)((meanglb * prbn) - meanitr);
   param2 = (float)(param1 * param1) /(float) ( prbn * (1.0f - prbn) );

   if (param2 > param3)
   {
       param3 = param2;
       OPT_THRESH_VAL = i;     // Update the "Weight/Value" as Optimum Threshold value
   }
  }

  cvThreshold(gray,thres,OPT_THRESH_VAL,255,CV_THRESH_BINARY); // Threshold the Image using the value obtained from OTSU method

  cvShowImage( "Camera",img);
  cvShowImage( "Threshold",thres);

  key = cvWaitKey(1); // OPENCV: wait for 1ms before accessing next frame

 } // End of while loop

 cvDestroyWindow( "Camera" ); // Release various parameters
 cvReleaseImage(&img);
 cvReleaseImage(&gray);
 cvReleaseImage(&thres);
     return 0;
}
// End of Main Loop
//------------------------------------------------------------------------------------------------------------------------

OpenCV: Build a simple OpenCV program using CMake in Ubuntu

2014-07-26T10:29:00.000-07:00

Building on our progress with usage of OpenCV, a demo on how to build and run a C++ based OpenCV program is described below.

To understand whats happing under the hood we shall dig up some basics -
g++ is GNU compiler for C++. Capable of generating both program object files and Executables
Make is a Build Tool that generates executables also by invoking g++
CMake , I would prefer to call it as Build Environment Tool that manages and assists the Build Process

CMake is a tool that takes care of managing what are the key requisites for the source to be compiled. More often than not, the source are dependent on other sources that have their own stipulations and methods to build them. Usually the build requirements of these components are mentioned in their respective 'CMakeLists'. Thus combining the 'CMakeLists' of the program and dependent sources, CMake makes it easier to manage and mitigate the task of providing and maintaining these component specific build requirements. This way the programmer can focus more on the necessities of the program rather than the needs of its dependent components. Further more, a well written CMake file makes the sources portable for building across platforms.

Quick Bullets:
Author --> Creates a program and CMakeList.txt
CMake and CMakeList.txt --> Generates Build Parameters [Makefile] for Build tools
Make and Makefile --> Generates Compiler Parameters and Invokes g++
g++ and Compiler Options --> Generates Object files and Executables

A simple diagram might provide more clarity. See below -

Let us call our sample program as 'display_code.cpp' and the executable as 'display'

Create simple OpenCV program named 'display_code.cpp' [Note: Using legacy OpenCV 1.0 API]

#include <cv.h>
#include <highgui.h>

int main(int argc, char** argv )
{
 IplImage* img = cvLoadImage("nexus.jpg");
 cvNamedWindow("Image",CV_WINDOW_AUTOSIZE);
 cvShowImage( "Image",img);
 int key = cvWaitKey(0);

 cvDestroyWindow( "Image" );
 cvReleaseImage(&img);
}

Create 'CMakeLists.txt'

cmake_minimum_required(VERSION 2.8)
project( display )
find_package( OpenCV REQUIRED )
add_executable( display display_code.cpp )
target_link_libraries( display ${OpenCV_LIBS} )

Build the application

cmake .

make

Run the application

./display

OR
Using g++ directly

g++ display_code.cpp -o display `pkg-config --cflags --libs opencv`
./display

Result:

Files:
Download from DsynFLO box folder - https://app.box.com/s/yn3lwcmx1sv4slz0wfru

Further Reading:
GCC and Make : http://www3.ntu.edu.sg/home/ehchua/programming/cpp/gcc_make.html
Writing Makefiles : https://www.cs.bu.edu/teaching/cpp/writing-makefiles/
Follow the informative answer explaining 'CMake' and 'Make' here - http://stackoverflow.com/a/19266355

Installing OpenCV 2.4.9 in Ubuntu 14.04

2014-07-20T00:28:00.000-07:00

In the previous post information on Ubuntu installation was shared, in this post we shall see how to install OpenCV in Ubuntu 14.04.

Note : The Instructions are from the site below. The same has been posted here for reference -
http://www.sysads.co.uk/2014/05/install-opencv-2-4-9-ubuntu-14-04-13-10/

Step 1 The first step here is the most important step. And the first step is to update the list of package repositories. This will come in handy while installing latest packages and their dependencies described in upcoming steps.

sudo apt-get update

This will take a while. I would suggest a cup of coffee.

Step 2 Remove previously installed FFMPEG and x264 libraries

sudo apt-get remove ffmpeg x264 libx264-dev

Step 3 Once this is completed, install the necessary packages for compiling openCV sources
Note: The package “ocl-icd-libopencl1” is selected for the following installation as my system does not contain NVIDIA graphics card. If your system has NVIDIA card then install ‘libopencv-dev’ instead of
‘ocl-icd-libopencl1’.

sudo apt-get install ocl-icd-libopencl1 build-essential checkinstall cmake pkg-config 
yasm libjpeg-dev libjasper-dev libavcodec-dev libavformat-dev libswscale-dev 
libdc1394-22-dev libxine-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev 
libv4l-dev python-dev python-numpy libtbb-dev libqt4-dev libgtk2.0-dev libfaac-dev 
libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev 
libxvidcore-dev x264 v4l-utils

Notice most of the packages are already installed during Ubuntu Installation. If not it will be installed now anyway.

Note: In this sample, the system contains AMD [ATI Radeon] graphics card

Step 4 Make a directory to download and build OpenCV

mkdir opencv
cd /opencv/

Step 5 Download the OpenCV sources for linux or Click here to start download. Unzip the OpenCV Sources.

wget -O OpenCV-2.4.9.zip http://fossies.org/linux/misc/opencv-2.4.9.zip
unzip OpenCV-2.4.9.zip
cd opencv-2.4.9

Step 6 Create a directory for compiling the sources

mkdir build
cd build

Step 7 Start building sources using CMAKE and install.

Important !! Make sure that the hierarchical path to the OpenCV sources does not contain any spaces.
Ex:

/home/bhp/my stuff/opencv src compilation/opencv2.4.9 <<--incorrect

/home/bhp/my_stuff/opencv/opencv2.4.9/ <<--better

Now compile the sources with all support and install

cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON 
-D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D INSTALL_C_EXAMPLES=ON 
-D INSTALL_PYTHON_EXAMPLES=ON -D BUILD_EXAMPLES=ON -D WITH_QT=ON -D WITH_OPENGL=ON ..

The next step will take a while. Use multiple jobs to 'make' faster. [Ex: make -j8]

make
sudo make install

sudo sh -c 'echo "/usr/local/lib" > /etc/ld.so.conf.d/opencv.conf'
sudo ldconfig

Step 8 Reboot the system for everything to take effect.

Step 9 Run an example C++ code provided with OpenCV Sources

cd /usr/local/share/OpenCV/samples/cpp
g++ houghlines.cpp -o application `pkg-config --cflags --libs opencv`
./application

Result

Installing Ubuntu 14.04 LTS

2014-07-19T09:14:00.000-07:00

Before we get on to the exciting stuff (- coming soon!!), we shall get started with installation of Ubuntu. So head over to Ubuntu site to download the CD/DVD image and follow the official guide for installation.

Ubuntu Desktop Images
http://www.ubuntu.com/download/desktop

Ubuntu Official Installation Guide
http://www.ubuntu.com/download/desktop/install-ubuntu-desktop

For installing Ubuntu alongside Windows follow the video tutorial below -

Caution: In case you have multiple Hard disk drives in your system, and you falter while picking the right Hard disk for Ubuntu installation, you can still recover the NTFS partition table and some of the partitions other than the region where Ubuntu was installed. You can do that by using “MiniTool Partition Wizard” which will allow you to restore lost partitions by scanning entire drive space.

Note: If the data is not overwritten on the disk space but if the partitions are lost, then the data is still intact and only the partition table needs to be restored.
Note 2: MiniTool is a shareware, it allows users to restore partitions but does not allow recovery of files with trail version. However restoring of Partition table is possible with trail version.

Links:
MiniTool Partition Wizard (Shareware)
http://www.partitionwizard.com/free-partition-manager.html

Ubuntu + Windows Dual boot video tutorial
https://www.youtube.com/watch?v=hOz66FC0pWU

Enter the Orange: Xiaomi finally enters India with MI3

2014-07-09T08:13:00.002-07:00

After waiting for an eternity, Xiaomi have decided to launch MI3 in India starting on July 15th 2014. I have been a big fan of MIUI and availability of official MIUI supported device locally is thing to cheer for. I have to proclaim that MIUI group has been more creative community from very early stages. MIUI has been the top variety of Android Custom Skin. Vanilla version on its own and Cyanogenmod do not bring the appeal to use Android much, neither have Samsung TouchWiz and Sony's skin [Xperia?]. Off late, HTC Sense and LG Optimus UI have given some sort of direction for Android L to progress with. But MIUI's blend of iOS elegance and Android's versatility has a special place and a highly devoted fanclub.

The segment (between Rs.10k to Rs.26k) was initially dominated by Samsung with Grand variants is now smeared by Micromax which is seeded to become India's top mobile vendors. Xiaomi's entry into Indian market at the price of Rs.14999 will be highly competitive.

Xiaomi Mi3 India: http://www.mi.com/in/
Xiaomi Mi3 Global: http://www.mi.com/en/mi3
MIUI ROMS: http://en.miui.com

Gingerbread for Nexus One: Android 2.3.3

2011-02-24T20:16:00.000-08:00

After a long wait...Gingerbread is now available for Nexus One..
The update is from 2.2.2 to 2.3.3 (FRG83G to GRI40)
Go ahead and flash it-

Link:
http://android.clients.google.com/packages/ota/passion/81304b2de707.signed-passion-GRI40-from-FRG83G.81304b2d.zip

Mediafire Link:
http://www.mediafire.com/?2n99su2rcfaq83f

Sony Ericsson LiveView Update

2011-01-28T08:50:00.000-08:00

Sony Ericsson has launched the firmware update for LiveView. Connect your Liveview to a PC and update.

-Install the Package on a PC.
-Switch off the LiveView and connect to PC via Micro USB Cable.
-Press and Hold Select button.
-Now press and hold Power button till USB logo shows up in the LiveView.
-Install Update. Unplug after succesful install.
-Unpair LiveView in the Phone and pair again and connect.

Link:
http://www.sonyericsson.com/cws/products/accessories/overview/liveviewmicrodisplay?cc=gb&lc=en#a

Update:
Update_Service_Setup-2.11.1.9.exe [EXE] 36MB

Details:

http://blogs.sonyericsson.com/products/2011/01/28/liveview%E2%84%A2-update-now-live/

Sony Ericsson LiveView Details

2011-01-26T02:12:00.000-08:00

I recently purchased a Sony Ericsson LiveView from Amazon.Since then I have been using it. Although there are some shortcomings, I'm really impressed to say the least.

©Sony Ericsson

Sony Ericsson LiveView

1.3” OLED Screen

128x128 pixels

Bluetooth 2.1

In the Box: 1 Watch strap with Velcro strip,

2 Flanged Spring Bars,

1 snap-on holder for Watch,

1 snap-on Clip (attached to LiveView)

1 Micro-B USB Charger (5V, 550mA)

User guide, Legal Information booklets

The performance of the device is pretty neat. The device works like a charm when connected but constant disconnection causes dissatisfaction. The device disconnects unpredictably possibly due to firmware issue or limitations in it's bluetooth range. The Device becomes unresponsive if the LiveView app is killed. The Music plugin however doesn't seem to be working with my Nexus One.

Default Plugins:

Plugins	Status	Notifications	Comments
Messages	works fine	Sender’s name, Full Message	-
Facebook	Patchy	User Name: Likes, Comments & Messages (Basic Fb Notifications)	Notifications slow to arrive
Twitter	works fine	User Name, Full tweet	-
Find phone	works fine	Phone makes 3 Notification rings	Limited to connectivity and of course range.
RSS	works fine	Feed name,Full feed entry	-
Calendar	works fine	Event timings, Event details	-
Missed calls	works fine	Caller :Name, Number & Time of call	-
Active Calls	works fine	Caller Name or Number if name unknown	-

Third Party plugins:

Plugins	Status	Notifications	Comments
Gmail	works fine	Full Mail	-
PowerAmp	Brilliant	Music control: Play/Pause, Next/Previous, Volume Up/Down. Clock Mode.	Album Art & Song Details not showing up.*
ContactCall	works fine	Contact Image, Contact Name or Number if name unknown	Plugin works brilliantly, but navigating to the person to call is a pain. How about a shortcut to Favorite callers only??*
Launcher	works fine	Full App drawer	Icon rendering needs to be cleaned up.

Battery Life:

7 Hrs of an eventful day with Notifications,

24 Hrs on standby, without sync.

Conclusion:

The Bluetooth connection needs to be improved. Good implementation of the concept.

*Update [Jan 27]:
PowerAmp plugin shows AlbumArt if scrobbling is enabled.
ContactCall has options to select groups like (All Contacts,Starred in Android...) to display in LiveView

Press Shots ©Sony Ericsson:

Images:

Nexus One Headset Controls: Issue, Solution and the Aftermath

2011-01-16T02:50:00.000-08:00

I've been using the Nexus One Headset for quite some time now and never had any problems. However recently I found out that the Headset controls stopped responding while the headphones were working fine. My first assumption was that some application would have latched on to the control bits. So I killed most of the applications, then rebooted and I also factory reset the phone, but the issue persisted.

The issue was with the hardware. I connected a spare HTC Desire headset to my phone, to no surprise it worked. So the fault was with the my Headset.

After searching the web and tearing in to the hardware I could finally solve the problem. Here is how-

The Problem:

The Unshielded copper wire wound around within the cable had torn due to twisting and turning of the cable.

This is the common (GND) for the function keys and hence the controls didn’t work.

Verifying it:

Hold the Multimeter across the 4th Connector (Sleeve) and the 3rd Connector (counting from the tip). The Multimeter should read as shorted or Zero Ohms when you press the play button.

Some of the Resistance readings across 4^th and 3^rd connectors:

Buttons pressed	Resistance (Ideal value)	Resistance (Recurring stable value)
Play/Pause	0 Ω (short-circuit)	0 Ω (short-circuit)
Previous	220 Ω	221 Ω
Next	600 Ω	605 Ω

Solution:

I connected the torn wires again and the controls worked. But I had to replace the jack with a new one since the copper wire had torn very close to the plug.

Note:

The plug is TRRS (Tip-Ring-Ring-Sleeve) type 3.5mm.

Headset affected:

HTC RC E150/E160

Similar Headsets are provided with:

Desire, Desire Z, Desire HD

Below are some the images and wiring diagrams that might help you. There are images of the headset controls dismantled just in case if you are interested.

Conclusion:

Handle your hardware with care :)

Images:

Android Weather Icons (Extended)

2011-01-16T01:02:00.000-08:00

Here are some extended set of the original one-

Previously: Android Weather Icons Set 1

Link:
Android Weather Icons Extended [ZIP] 598 kB

License: There is no license attached to this work. You are free to use them with or without modification.

Object:

Android: Weather Extended by ~bharathp666 on deviant ART

Image:

Android: Compass Application Concept (Templates)

2011-01-15T05:52:00.000-08:00

I like the HTC HD2 compass, and this is what i came up with-

License: There is no license attached to this work. You are free to use them with or without modification.

Link:
Compass App Concept [ZIP] 8.7 MB

Object:

Android: Compass App. Concept by ~bharathp666 on deviant ART

Images:

CR3: Android Music Player Concept (and Templates)

2011-01-15T03:35:00.000-08:00

The stock Android Music Player is very simple and easy to use, but isn't attractive. The new Gallery-ish Music player also sucks. So here is my music player / theme concept, that would turn some heads!!

Link:
Android Music Player Concept [ZIP] 7.4 Mb

Object:

Android: Music Player Concept by ~bharathp666 on deviant ART

Images:

Sony Ericsson Xperia X10 Templates

2011-01-14T22:48:00.000-08:00

This phone is Gorgeous. Timescape and Mediascape are awesome applications but tend to lag the X10. The below templates are 2000x2000pixels , contains both PSDs and PNGs.

Link:
Sony Ericsson Xperia X10 [ZIP] 19 MB

Objects:

Sony Ericsson Xperia X10 by ~bharathp666 on deviant ART

Images:

Sony Ericsson LiveView Templates

2011-01-14T22:11:00.000-08:00

These are the Sony Ericsson LiveView Templates. The Images are 600x600 pixels. The package contains both PSDs and PNGs.

Download them from DeviantArt.

License: There is no license attached to this work. You are free to use them with or without modification.

Link:

Sony Ericsson LiveView [ZIP] 900kB

Image:

Object:

Android: LiveView by ~bharathp666 on deviant ART

Android Widgets

2010-10-10T09:05:00.000-07:00

The Android Widgets pack: It contains 14 widgets with .PSD files so that you can edit and modify any way you want.
Also it has PSD templates for Notification bar and Launcher tray.
Download them from DeviantArt.

Link:
Android Widgets Pack [ZIP] 2 Mb

Image:

Object:
License: There is no license attached to this work. You are free to use them with or without modification.

Android: Widgets by ~bharathp666 on deviant ART

Android Weather Icons

2010-10-10T08:54:00.000-07:00

Here are some default android weather icons-

Object:

Android: Weather Icons by ~bharathp666 on deviant ART

License: There is no license attached to this work. You are free to use them with or without modification.