My Thoughts

Spam Blog

2009-04-15T10:39:00.000-07:00

Google detected that this is a spam blog? Could not really believe it since it has so few posts :))

But lets see what their review says! I am open for review!

Blogger Import

2009-04-15T10:36:00.000-07:00

I am trying to classify my blogs and hence created a new blog. I moved my blog from another account into this one and to my surprise, Google actually thought this is a spam blog. lets see how this goes further :)

Anyways a nice spot for blogging, I am surprised that Thoughts At The World was available in blogger http://thoughtsattheworld.blogspot.com/

Convert All files in a directory

2005-12-04T15:33:00.000-08:00

find ./*.ppm -exec convert {} {}.jpg \;

LZW Encoding Scheme C++

2005-11-30T06:14:00.000-08:00

/********************************************************************
**
** Copyright (c) 1989 Mark R. Nelson
**
** LZW data compression/expansion demonstration program.
**
** April 13, 1989
**
*****************************************************************************/
#include
#include
#include
#include

#define BITS 14 /* Setting the number of bits to 12, 13*/
#define HASHING_SHIFT BITS-8 /* or 14 affects several constants. */
#define MAX_VALUE (1 << BITS) - 1 /* Note that MS-DOS machines need to */
#define MAX_CODE MAX_VALUE - 1 /* compile their code in large model if*/
/* 14 bits are selected. */
#if BITS == 14
#define TABLE_SIZE 18041 /* The string table size needs to be a */
#endif /* prime number that is somewhat larger*/
#if BITS == 13 /* than 2**BITS. */
#define TABLE_SIZE 9029
#endif
#if BITS <= 12
#define TABLE_SIZE 5021
#endif

int *code_value; /* This is the code value array */
unsigned int *prefix_code; /* This array holds the prefix codes */
unsigned char *append_character; /* This array holds the appended chars */
unsigned char decode_stack[4000]; /* This array holds the decoded string */

/********************************************************************
**
** This program gets a file name from the command line. It compresses the
** file, placing its output in a file named test.lzw. It then expands
** test.lzw into test.out. Test.out should then be an exact duplicate of
** the input file.
**
*************************************************************************/

void output_code(FILE *output,unsigned int code);
void compress(FILE *input,FILE *output);
int find_match(int hash_prefix,unsigned int hash_character);
void expand(FILE *input,FILE *output);
unsigned char *decode_string(unsigned char *buffer,unsigned int code);
unsigned int input_code(FILE *input);

int main(int argc, char *argv[])
{
FILE *input_file;
FILE *output_file;
FILE *lzw_file;
char input_file_name[81];

/*
** The three buffers are needed for the compression phase.
*/
code_value=( int*)malloc(TABLE_SIZE*sizeof(unsigned int));
prefix_code=(unsigned int*)malloc(TABLE_SIZE*sizeof(unsigned int));
append_character=(unsigned char*)malloc(TABLE_SIZE*sizeof(unsigned char));
if (code_value==NULL || prefix_code==NULL || append_character==NULL)
{
printf("Fatal error allocating table space!\n");
exit(1);
}
/*
** Get the file name, open it up, and open up the lzw output file.
*/
if (argc>1)
strcpy(input_file_name,argv[1]);
else
{
printf("Input file name? ");
scanf("%s",input_file_name);
}
input_file=fopen(input_file_name,"rb");
lzw_file=fopen("test.lzw","wb");
if (input_file==NULL || lzw_file==NULL)
{
printf("Fatal error opening files.\n");
exit(1);
};
/*
** Compress the file.
*/
compress(input_file,lzw_file);
fclose(input_file);
fclose(lzw_file);
free(code_value);
/*
** Now open the files for the expansion.
*/
lzw_file=fopen("test.lzw","rb");
output_file=fopen("test.out","wb");
if (lzw_file==NULL || output_file==NULL)
{
printf("Fatal error opening files.\n");
exit(1);
};
/*
** Expand the file.
*/
expand(lzw_file,output_file);
fclose(lzw_file);
fclose(output_file);

free(prefix_code);
free(append_character);
}

/*
** This is the compression routine. The code should be a fairly close
** match to the algorithm accompanying the article.
**
*/

void compress(FILE *input,FILE *output)
{
unsigned int next_code;
unsigned int character;
unsigned int string_code;
unsigned int index;
int i;
int t;
next_code=256; /* Next code is the next available string code*/
for (i=0;i code_value[i]=-1;

i=0;
printf("Compressing...\n");
ifstream file("ratios");
file >> t;
string_code=t;
/*
** This is the main loop where it all happens. This loop runs util all of
** the input has been exhausted. Note that it stops adding codes to the
** table after all of the possible codes have been defined.
*/

//732 * 1214
//while ((character=getc(input)) != (unsigned)EOF)
for(i=0;i<732*1214-1;i++)
{
file >> t; character =t;
if (++i==1000) /* Print a * every 1000 */
{ /* input characters. This */
i=0; /* is just a pacifier. */
printf("*");
}
index=find_match(string_code,character);/* See if the string is in */
if (code_value[index] != -1) /* the table. If it is, */
string_code=code_value[index]; /* get the code value. If */
else /* the string is not in the*/
{ /* table, try to add it. */
if (next_code <= MAX_CODE)
{
code_value[index]=next_code++;
prefix_code[index]=string_code;
append_character[index]=character;
}
output_code(output,string_code); /* When a string is found */
string_code=character; /* that is not in the table*/
} /* I output the last string*/
} /* after adding the new one*/
/*
** End of the main loop.
*/
output_code(output,string_code); /* Output the last code */
output_code(output,MAX_VALUE); /* Output the end of buffer code */
output_code(output,0); /* This code flushes the output buffer*/
printf("\n");
}

/*
** This is the hashing routine. It tries to find a match for the prefix+char
** string in the string table. If it finds it, the index is returned. If
** the string is not found, the first available index in the string table is
** returned instead.
*/

int find_match(int hash_prefix,unsigned int hash_character)
{
int index;
int offset;

index = (hash_character << HASHING_SHIFT) ^ hash_prefix;
if (index == 0)
offset = 1;
else
offset = TABLE_SIZE - index;
while (1)
{
if (code_value[index] == -1)
return(index);
if (prefix_code[index] == hash_prefix &&
append_character[index] == hash_character)
return(index);
index -= offset;
if (index < 0)
index += TABLE_SIZE;
}
}

/*
** This is the expansion routine. It takes an LZW format file, and expands
** it to an output file. The code here should be a fairly close match to
** the algorithm in the accompanying article.
*/

void expand(FILE *input,FILE *output)
{
unsigned int next_code;
unsigned int new_code;
unsigned int old_code;
int character;
int counter;
unsigned char *string;
int t;

ofstream file("output");
next_code=256; /* This is the next available code to define */
counter=0; /* Counter is used as a pacifier. */
printf("Expanding...\n");

old_code=input_code(input); /* Read in the first code, initialize the */
character=old_code; /* character variable, and send the first */

t=(unsigned char) old_code;
file << t;
putc(old_code,output); /* code to the output file */
/*
** This is the main expansion loop. It reads in characters from the LZW file
** until it sees the special code used to inidicate the end of the data.
*/
while ((new_code=input_code(input)) != (MAX_VALUE))
{

if (++counter==1000) /* This section of code prints out */
{ /* an asterisk every 1000 characters */
counter=0; /* It is just a pacifier. */
printf("*");
}
/*
** This code checks for the special STRING+CHARACTER+STRING+CHARACTER+STRING
** case which generates an undefined code. It handles it by decoding
** the last code, and adding a single character to the end of the decode string.
*/
if (new_code>=next_code)
{
*decode_stack=character;
string=(unsigned char*)decode_string(decode_stack+1,old_code);
}
/*
** Otherwise we do a straight decode of the new code.
*/
else
string=(unsigned char*)decode_string(decode_stack,new_code);
/*
** Now we output the decoded string in reverse order.
*/
character=*string;
while (string >= decode_stack)
{
t=(unsigned char) *string;
file << t;
putc(*string--,output);
}
/*
** Finally, if possible, add a new code to the string table.
*/
if (next_code <= MAX_CODE)
{
prefix_code[next_code]=old_code;
append_character[next_code]=character;
next_code++;
}
old_code=new_code;
}
printf("\n");
}

/*
** This routine simply decodes a string from the string table, storing
** it in a buffer. The buffer can then be output in reverse order by
** the expansion program.
*/

unsigned char *decode_string(unsigned char *buffer,unsigned int code)
{
int i;

i=0;
while (code > 255)
{
*buffer++ = append_character[code];
code=prefix_code[code];
if (i++>=4094)
{
printf("Fatal error during code expansion.\n");
exit(1);
}
}
*buffer=code;
return(buffer);
}

/*
** The following two routines are used to output variable length
** codes. They are written strictly for clarity, and are not
** particularyl efficient.
*/

unsigned int input_code(FILE *input)
{
unsigned int return_value;
static int input_bit_count=0;
static unsigned long input_bit_buffer=0L;

while (input_bit_count <= 24)
{
input_bit_buffer |=
(unsigned long) getc(input) << (24-input_bit_count);
input_bit_count += 8;
}
return_value=input_bit_buffer >> (32-BITS);
input_bit_buffer <<= BITS;
input_bit_count -= BITS;
return(return_value);
}

void output_code(FILE *output,unsigned int code)
{
static int output_bit_count=0;
static unsigned long output_bit_buffer=0L;

output_bit_buffer |= (unsigned long) code << (32-BITS-output_bit_count);
output_bit_count += BITS;
while (output_bit_count >= 8)
{
putc(output_bit_buffer >> 24,output);
output_bit_buffer <<= 8;
output_bit_count -= 8;
}
}

Good Huffman Encoding Code Simple

2005-11-30T05:32:00.000-08:00

#include

#include
#include
#include
#include

//
// The node class is used to represent both leaf
// and internal nodes. leaf nodes have 0s in the
// child pointers, and their value member corresponds
// to the character they encode. internal nodes
// don't have anything meaningful in their value
// member, but their child pointers point to
// other nodes.
//

using namespace std;
struct node {
int weight;
unsigned char value;
const node *child0;
const node *child1;
//
// Construct a new leaf node for character c
//
node( unsigned char c = 0, int i = -1 ) {
value = c;
weight = i;
child0 = 0;
child1 = 0;
}
//
// Construct a new internal node that has
// children c1 and c2.
//
node( const node* c0, const node *c1 ) {
value = 0;
weight = c0->weight + c1->weight;
child0 = c0;
child1 = c1;
}
//
// The comparison operator used to order the
// priority queue.
//
bool operator<( const node &a ) const {
return weight < a.weight;
}
void traverse( string code = "" ) const;
};

//
// The traverse member function is used to
// print out the code for a given node. It
// is designed to print the entire tree if
// called for the root node.
//

void node::traverse( string code ) const
{
if ( child0 ) {
child0->traverse( code + "0" );
child1->traverse( code + "1" );
} else {
cout << " " << value << " ";
//cout << setw( 2 ) << weight;
cout << " " << code << endl;
}
}

//
// This routine does a quick count of all the
// characters in the input file. I skip the
// whitespace.
//

void count_chars( int *counts )
{
for ( int i = 0 ; i < 256 ; i++ )
counts[ i ] = 0;
ifstream file( "input.dat" );
if ( !file ) {
cerr << "Couldn't open the input file!\n";
throw "abort";
}
file.setf( ios::skipws );
for ( ; ; ) {
unsigned char c;
file >> c;
if ( file )
counts[ c ]++;
else
break;
}
}

main()
{
int counts[ 256 ];

count_chars( counts );
priority_queue< vector< node >, vector > q;
//
// First I push all the leaf nodes into the queue
//
for ( int i = 0 ; i < 256 ; i++ )
if ( counts[ i ] )
q.push( node( i, counts[ i ] ) );
//
// This loop removes the two smallest nodes from the
// queue. It creates a new internal node that has
// those two nodes as children. The new internal node
// is then inserted into the priority queue. When there
// is only one node in the priority queue, the tree
// is complete.
//

while ( q.size() > 1 ) {
node *child0 = new node( q.top() );
q.pop();
node *child1 = new node( q.top() );
q.pop();
q.push( node( child0, child1 ) );
}
//
// Now I dump the results
//
cout << "Char Symbol Code" << endl;
q.top().traverse();
return 1;
}

Debauchies Wavelets Good Sample Code

2005-11-30T04:03:00.000-08:00

#include
#include

/**

Daubechies D4 wavelet transform (D4 denotes four coefficients)

I have to confess up front that the comment here does not even come
close to describing wavelet algorithms and the Daubechies D4
algorithm in particular. I don't think that it can be described in
anything less than a journal article or perhaps a book. I even have
to apologize for the notation I use to describe the algorithm, which
is barely adequate. But explaining the correct notation would take
a fair amount of space as well. This comment really represents some
notes that I wrote up as I implemented the code. If you are
unfamiliar with wavelets I suggest that you look at the bearcave.com
web pages and at the wavelet literature. I have yet to see a really
good reference on wavelets for the software developer. The best
book I can recommend is Ripples in Mathematics by Jensen and
Cour-Harbo.

All wavelet algorithms have two components, a wavelet function and a
scaling function. These are sometime also referred to as high pass
and low pass filters respectively.

The wavelet function is passed two or more samples
and calculates a wavelet coefficient. In the case of
the Haar wavelet this is


  coef_i = odd_i - even_i
  or 
  coef_i = 0.5 * (odd_i - even_i)

depending on the version of the Haar algorithm used.

The scaling function produces a smoother version of the
original data. In the case of the Haar wavelet algorithm
this is an average of two adjacent elements.

The Daubechies D4 wavelet algorithm also has a wavelet
and a scaling function. The coefficients for the
scaling function are denoted as h_i and the
wavelet coefficients are g_i.

Mathematicians like to talk about wavelets in terms of
a wavelet algorithm applied to an infinite data set.
In this case one step of the forward transform can be expressed
as the infinite matrix of wavelet coefficients
represented below multiplied by the infinite signal
vector.


     a_i = ...h0,h1,h2,h3, 0, 0, 0, 0, 0, 0, 0, ...   s_i
     c_i = ...g0,g1,g2,g3, 0, 0, 0, 0, 0, 0, 0, ...   s_i+1
   a_i+1 = ...0, 0, h0,h1,h2,h3, 0, 0, 0, 0, 0, ...   s_i+2
   c_i+1 = ...0, 0, g0,g1,g2,g3, 0, 0, 0, 0, 0, ...   s_i+3
   a_i+2 = ...0, 0, 0, 0, h0,h1,h2,h3, 0, 0, 0, ...   s_i+4
   c_i+2 = ...0, 0, 0, 0, g0,g1,g2,g3, 0, 0, 0, ...   s_i+5
   a_i+3 = ...0, 0, 0, 0, 0, 0, h0,h1,h2,h3, 0, ...   s_i+6
   c_i+3 = ...0, 0, 0, 0, 0, 0, g0,g1,g2,g3, 0, ...   s_i+7

The dot product (inner product) of the infinite vector and
a row of the matrix produces either a smoother version of the
signal (a_i) or a wavelet coefficient (c_i).

In an ordered wavelet transform, the smoothed (a_i) are
stored in the first half of an n element array region. The
wavelet coefficients (c_i) are stored in the second half
the n element region. The algorithm is recursive. The
smoothed values become the input to the next step.

The transpose of the forward transform matrix above is used
to calculate an inverse transform step. Here the dot product is
formed from the result of the forward transform and an inverse
transform matrix row.


      s_i = ...h2,g2,h0,g0, 0, 0, 0, 0, 0, 0, 0, ...  a_i
    s_i+1 = ...h3,g3,h1,g1, 0, 0, 0, 0, 0, 0, 0, ...  c_i
    s_i+2 = ...0, 0, h2,g2,h0,g0, 0, 0, 0, 0, 0, ...  a_i+1
    s_i+3 = ...0, 0, h3,g3,h1,g1, 0, 0, 0, 0, 0, ...  c_i+1
    s_i+4 = ...0, 0, 0, 0, h2,g2,h0,g0, 0, 0, 0, ...  a_i+2
    s_i+5 = ...0, 0, 0, 0, h3,g3,h1,g1, 0, 0, 0, ...  c_i+2
    s_i+6 = ...0, 0, 0, 0, 0, 0, h2,g2,h0,g0, 0, ...  a_i+3
    s_i+7 = ...0, 0, 0, 0, 0, 0, h3,g3,h1,g1, 0, ...  c_i+3

Using a standard dot product is grossly inefficient since most
of the operands are zero. In practice the wavelet coefficient
values are moved along the signal vector and a four element
dot product is calculated. Expressed in terms of arrays, for
the forward transform this would be:


  a_i = s[i]*h0 + s[i+1]*h1 + s[i+2]*h2 + s[i+3]*h3
  c_i = s[i]*g0 + s[i+1]*g1 + s[i+2]*g2 + s[i+3]*g3

This works fine if we have an infinite data set, since we don't
have to worry about shifting the coefficients "off the end" of
the signal.

I sometimes joke that I left my infinite data set in my other bear
suit. The only problem with the algorithm described so far is that
we don't have an infinite signal. The signal is finite. In fact
not only must the signal be finite, but it must have a power of two
number of elements.

If i=N-1, the i+2 and i+3 elements will be beyond the end of
the array. There are a number of methods for handling the
wavelet edge problem. This version of the algorithm acts
like the data is periodic, where the data at the start of
the signal wraps around to the end.

This algorithm uses a temporary array. A Lifting Scheme version of
the Daubechies D4 algorithm does not require a temporary. The
matrix discussion above is based on material from Ripples in
Mathematics, by Jensen and Cour-Harbo. Any error are mine.

Author: Ian Kaplan

Use: You may use this software for any purpose as long
as I cannot be held liable for the result. Please credit me
with authorship if use use this source code.

This comment is formatted for the doxygen documentation generator

*/
class Daubechies {
private:
/** forward transform scaling coefficients */
double h0, h1, h2, h3;
/** forward transform wave coefficients */
double g0, g1, g2, g3;

double Ih0, Ih1, Ih2, Ih3;
double Ig0, Ig1, Ig2, Ig3;

/**
Forward Daubechies D4 transform
*/
public:
void transform( double* a, const int n )
{
if (n >= 4) {
int i, j;
const int half = n >> 1;

double* tmp = new double[n];

for (i = 0, j = 0; j < n-3; j += 2, i++) {
tmp[i] = a[j]*h0 + a[j+1]*h1 + a[j+2]*h2 + a[j+3]*h3;
tmp[i+half] = a[j]*g0 + a[j+1]*g1 + a[j+2]*g2 + a[j+3]*g3;
}

tmp[i] = a[n-2]*h0 + a[n-1]*h1 + a[0]*h2 + a[1]*h3;
tmp[i+half] = a[n-2]*g0 + a[n-1]*g1 + a[0]*g2 + a[1]*g3;

for (i = 0; i < n; i++) {
a[i] = tmp[i];
}
delete [] tmp;
}
}

/**
Inverse Daubechies D4 transform
*/
void invTransform( double* a, const int n )
{
if (n >= 4) {
int i, j;
const int half = n >> 1;
const int halfPls1 = half + 1;

double* tmp = new double[n];

// last smooth val last coef. first smooth first coef
tmp[0] = a[half-1]*Ih0 + a[n-1]*Ih1 + a[0]*Ih2 + a[half]*Ih3;
tmp[1] = a[half-1]*Ig0 + a[n-1]*Ig1 + a[0]*Ig2 + a[half]*Ig3;
for (i = 0, j = 2; i < half-1; i++) {
// smooth val coef. val smooth val coef. val
tmp[j++] = a[i]*Ih0 + a[i+half]*Ih1 + a[i+1]*Ih2 + a[i+halfPls1]*Ih3;
tmp[j++] = a[i]*Ig0 + a[i+half]*Ig1 + a[i+1]*Ig2 + a[i+halfPls1]*Ig3;
}
for (i = 0; i < n; i++) {
a[i] = tmp[i];
}
delete [] tmp;
}
}

Daubechies()
{
const double sqrt_3 = sqrt( 3 );
const double denom = 4 * sqrt( 2 );

//
// forward transform scaling (smoothing) coefficients
//
h0 = (1 + sqrt_3)/denom;
h1 = (3 + sqrt_3)/denom;
h2 = (3 - sqrt_3)/denom;
h3 = (1 - sqrt_3)/denom;
//
// forward transform wavelet coefficients
//
g0 = h3;
g1 = -h2;
g2 = h1;
g3 = -h0;

Ih0 = h2;
Ih1 = g2; // h1
Ih2 = h0;
Ih3 = g0; // h3

Ig0 = h3;
Ig1 = g3; // -h0
Ig2 = h1;
Ig3 = g1; // -h2
}

void daubTrans( double* ts, int N )
{
int n;
for (n = N; n >= 4; n >>= 1) {
transform( ts, n );
}
}

void invDaubTrans( double* coef, int N )
{
int n;
for (n = 4; n <= N; n <<= 1) {
invTransform( coef, n );
}
}

}; // Daubechies

int main()
{
double A[8] = {1, 1, 2, 5 , 6, 2, 4, 3};
int i;
for(i=0;i<8;i++)
cerr<< A[i]<<" ";
cerr<< endl;

Daubechies D;
D.daubTrans( (double*)A , 8 );

for(i=0;i<8;i++)
cerr<< A[i]<<" ";
cerr<< endl;

D.invDaubTrans( (double*)A , 8 );

for(i=0;i<8;i++)
cerr<< A[i] <<" ";
cerr<< endl;

return 1;
}

C String Manipulation

2005-07-25T06:25:00.000-07:00

Like most people I too feel that perl string manipulation is much better than C. But recently I found this function called strsep(). It is the best possible function.
I am copying it below. Anyone and every1 who has ever parsed a file in C and found it difficult must read this.

char* strsep(char **stringp ,char *delim);
stringp is the initial string and delim is the delimiter character. The result is given as char* initial portion before the delimiter and rest is stored in stringp.

Eg. strcpy(string1,"shubham");
string2 = strsep(&string1,"u");

//Now string2 contains "sh" and string1 contains "bham"

Wallpaper from Yahoo API Wallpaper Generator

2005-07-21T00:11:00.000-07:00

Yahoo API wallpaper generator

2005-07-21T00:09:00.000-07:00

#! /usr/local/bin/perl -w
#############################################################################
# Yahoo Image Search Wallpaper Generator
#
# Written by Shubham Singal
# shubham@gmail.com
#
# ############################################################################

use strict;
use warnings 'all';
use Getopt::Long;
use LWP::Simple;
use constant AppUrl => "http://upster.blogspot.com/2005/03/" .
"yahoo-image-search-collage-generator.html";

use Yahoo::Search AppId => "wallpaper_maker";

my $rows = 10;
my $columns = 10;
my $total = $rows * $columns;
my $width = 80;
my $height = 60;
my $query = "";
my $help = 0;

GetOptions(
'query=s' => \$query,
'rows=i' => \$rows,
'columns=i' => \$columns,
'width=i' => \$width,
'height=i' => \$height,
'help' => \$help,
);

if ($help) {
print qq/$0
--query The text to search images for
[--rows ] The number of rows in the output HTML table
[--columns ] The number of columns in the output HTML table
[--width ] The width of each image in the output HTML table
[--height ] The height of each image in the output HTML table
[--help] Displays this message/;
exit;
}

die "Must specify a query!\n" unless ($query);

my $folder = "folder_to_store_temp_images";
if(-d $folder)
{
system("rm -rf $folder");
}

system("mkdir $folder");
my $i=0;
print "Querying Yahoo...";

while($total>0)
{
my @results = Yahoo::Search->Results(
Image => $query,
Count => 50,
Start => $i
);
print "\n Query DONE!\n";

my $size = $width."x".$height;
foreach (@results)
{
my $url = $_->ThumbUrl() ;
if (getstore($url, "$folder/$i.jpg") eq 200)
{
system("convert $folder/$i.jpg -resize $size $folder/resize_$i.jpg ");
print " $i";
$i++;

}
}
$total = $total - 50;
}

$i--;
print "\n Creating Wallpaper\n";
my $rc = $rows."x".$columns;
system("montage $folder/resize_*.jpg -tile $rc -geometry +2+2 Wallpaper_$query.jpg");

if(-d $folder)
{
system("rm -rf $folder");
}

print "\n Wallpaper Created\n";

ImageMagick Tutorial

2005-07-19T03:36:00.000-07:00

http://www.cit.gu.edu.au/~anthony/graphics/imagick6/

Good Link for Digital Image Processing

2005-06-30T02:17:00.000-07:00

http://www.yov408.com/html/tutorials.php?s=82

Remove Duplicate Files using Perl Script

2005-06-28T22:48:00.000-07:00

#!/usr/local/bin/perl
use File::stat;

my @files=glob("*.jpg");
for $fi (@files) {
$siz= stat($fi)->size;
$sizArr{$fi}=$siz;
# unshift(@sizArr, $siz);
# print "$siz\n";
}

#@sortSiz=sort(@sizArr);
#print @sortSiz;

$prevKey=0;
foreach $key (sort by_value keys %sizArr) {
$xx=$sizArr{$key};
if ($prevKey == $xx) {
print $key, '*', $xx, "\n";
#system("mv $key dups/");
} else {
print $key, '=', $xx, "\n";
}
$prevKey=$xx;
}

# sub by_value { $ary{$a} cmp $ary{$b}; }

sub by_value { $sizArr{$b} <=> $sizArr{$a}; }

One More Perl Script

2005-06-27T22:13:00.000-07:00

#!/usr/local/bin/perl
my @dlist=glob("Im*");
$kk=1;

for $dd (@dlist) {
print "$dd\n";
chdir $dd or die "Cannot change dir to $dd: $!\n";;
my @files=glob("*.jpg");
print "@files\n";
for $fi (@files) {
print "$fi\n";
system("mv $fi ../testImg/$kk-$fi");
}
chdir ".." or die "Cannot change dir to ..: $!\n";
$kk++;
}

Creating Stereo Images Easily

2005-06-23T00:02:00.000-07:00

http://www.photostuff.co.uk/stereo.htm
A cool link about creating Stereo Images

int red, green, blue;
int[] StereoPixels = (int[])anaglyphIP.getPixels();
int[] LeftPixels = (int[])LeftIP.getPixels(); // left eye image
int[] RightPixels = (int[])RightIP.getPixels(); // right eye image

for(int i=0;i< LWidth*LHeight;i++){
red = (LeftPixels[i] & 0xff0000)>> 16; //Left eye consists of red channel
green = (RightPixels[i] & 0xff00ff00)>>8; // Right eye image consists of green and blue channel
blue = (RightPixels[i] & 0x0000ff);

StereoPixels[i] = ((red & 0xff)<<16)+((green & 0xff)<<8) + (blue & 0xff);
}
anaglyphIP.setPixels(StereoPixels);

Another Bit Manipulation Function

2005-06-17T03:54:00.000-07:00

count=0;//count number of bits
k=2;//number of bits to be removed from R
unsigned char a1;
num=8;//bits empty in a1

int given(unsigned char R)
{
//right now a1 has num bits empty
//hence copy min(num,8-k) bits from R to a1
b_count=min(num,8-k);
if(num<8-k)
{
a=R>>(8-num);//num bits of R left in a
a1 = a1 | a;//fill a1 and write to disk
////write a1 to disk
if(num== (8-k))
{
//we have copied entire R after removing k bits hence no fight
num=8;//since written to disk consider a1 empty
}
else //some portion of R is left and hence we must copy that into a1
{
a=R>>k;// remove ending k bits of R
a=R<<(num+k);//remove starting num bits of R

a1=a;//copy all the bits to a1
num=k+num; // k + num bits of a1 are empty as of now
}
}
else
{
a=R>>k;//remove last k bits of R
a=a< a=a>>(8-num);//align with a1
a1=a1|a;//take or of a1 and a
num=num+8-k;
}

}

Get Unique Elements

2005-06-17T00:11:00.000-07:00

#! /usr/local/bin/perl -w
open(FILEREAD, "finale");
open(FILEWR, ">fin");
@in=;

undef %saw;
@out = grep(!$saw{$_}++, @in);
print @out;
print FILEWR @out;

Wavelets Haar Daubechies

2005-06-15T23:38:00.000-07:00

Wavelets here ... wavelets there ... but for computer vision and graphics I recommend these tutorials

http://www.bearcave.com/misl/misl_tech/wavelets/haar.html

AND

Wavelets for Computer Graphics: A Primer Part 1 and Part 2
in computer graphics with some intuition for what wavelets are, as ... Wavelets for Computer Graphics: Theory and Applications. ...
http://grail.cs.washington.edu/pub/stoll/wavelet1.pdf
http://grail.cs.washington.edu/pub/stoll/wavelet2.pdf

Html Text over an Image

2005-06-15T02:12:00.000-07:00

The Code That Does It

<TABLE BORDER="0" cellpadding="0" CELLSPACING="0">

<TR>

<TD WIDTH="221" HEIGHT="300" BACKGROUND="newjoe01.jpg" VALIGN="bottom">

<FONT SIZE="+1" COLOR="yellow">Joe Burns at Work</FONT></TD>

</TR>

</TABLE>

OR
USE DIV AND PLACEMENT
OR
go to http://www.htmlgoodies.com/tutorials/web_graphics/article.php/3480021

Perl Script: directory file manip

2005-06-15T02:08:00.000-07:00

To perform some actions on all files in a directory
#!/usr/bin/perl

$input_directory = ".";
chomp $input_directory;

until (-d $input_directory) { # the -d bit means check if there is a directory called ...
print "Sorry, that path / directory does not appear to exist, please try again.\n";
$input_directory = ;
chomp $input_directory;
}

opendir (INPUTDIR, $input_directory) || die "sorry, system cannot open $input_directory $input_directory";

while ($infile = readdir(INPUTDIR)) {
chomp $infile;
if ($infile !~ /^\./) {
if ($infile =~ /.*pgm/) {
$outfile = substr($infile,0,length($infile)-4);
print "\n convert $infile $outfile.jpg";
system("\n convert $infile $outfile.jpg");
}
}
}
closedir (INPUTDIR);

Store Images using Yahoo! API

2005-06-14T02:08:00.000-07:00

#! /usr/local/bin/perl -w

######program takes in keywords file and puts images in dir images/ and creates file Im
ageData with all the data for the images.
use strict;
use warnings 'all';
use Getopt::Long;
use LWP::Simple;
use Yahoo::Search AppId => "shubh_iitd";

my $i=0;
open(FILEREAD, "keywords");

open(FILEWRITE, ">ImageData");

while (){
print " word is: $_";
my $query=$_;
my @results = Yahoo::Search->Results(
Image => $query,
Count => 10
);

foreach (@results) {
my $url = $_->Url();
print "\n $i - $url";
if (getstore($url, "images/$i.jpg") eq 200){
my $im = 0;
open(IN, "images/$i.jpg");
binmode(IN);
read(IN,$b,4);
my $s = 2*length($b);
my $ch = unpack("H$s", $b);
print "\n |$ch| ";
if($ch eq "ffd8ffe0") {print " JPEG ";$im=1;}
if($ch eq "47494638") {print " GIF ";$im=1;}
if($ch eq "89504e47") {print " PNG ";$im=1;}
if($ch eq "4d4d002a") {print " TIFF Big Endian ";$im=1;}
if($ch eq "49492a00") {print " TIFF Little Endian ";$im=1;}
if($ch =~ /^424d/) {print " BMP ";$im=1;}
close(IN);
if($im eq 1){
$i++;
print FILEWRITE "$i.jpg - $url - $query\n";
}
}
}

}
close FILEREAD;
close FILEWRITE;

Read till EOF using FILE*

2005-06-07T01:17:00.000-07:00

To Read upto end of file using FILE* in c

while (fgets(fname,100,f))
{
//do anything
}

Bit Holder

2005-06-06T05:59:00.000-07:00

Class for storing bits as unsigned char for compression,
public:
IntC index;
IntC nbits;
IntC size;
IntC csize;
vector bits;//storing the bits, 8 bits in each unsigned char
unsigned char temp[8];//temprory for storing data
IntC tempsize;

void BitHolderInit(IntC dimension, IntC ind)
{
index=ind;
nbits=dimension;
IntC i; if(dimension%8) i=dimension/8; else i=dimension/8 + 1;
size = i; tempsize = 0; csize = 0;
}

int BitHolderWrite()
{
if (tempsize != 8) return -1;
//cerr<<"\n Csize : "<< csize <<" "<< size<<" "<< nbits<<" "<< tempsize;

bits.push_back( ((temp[0] & 0x1)<<7) | ((temp[1] & 0x1)<<6) | ((temp[2] & 0x1)
<< 5) | ((temp[3] & 0x1)<< 4) | ((temp[4] & 0x1)<< 3) | ((temp[5] & 0x1)<< 2) | ((temp[6] & 0x1)<< 1) | (temp[7] & 0x1) );
// bits.push_back(((temp[0] & 0x1)<<7) | ((temp[1] & 0x1)<<6 & 0x) | ((temp[
2] & 0x1)<<5) | ((temp[3] & 0x1)<<4) | ((temp[4] & 0x1)<<3) | ((temp[5] & 0x1)<<2)
| ((temp[6] & 0x1)<<1) | ((temp[7] & 0x1)));

tempsize=0; csize++;
temp[0]=temp[1]=temp[2]=temp[3]=temp[4]=temp[5]=temp[6]=temp[7]='0';
return 1;
}

int AddBit(IntC b)
{
//cerr<<" ADDING "<< b<<" "<< tempsize;
if(b==0) temp[tempsize]='0'; else temp[tempsize]='1';
tempsize++;
if(tempsize==8) BitHolderWrite();
}

int GetBit(IntC pos)
{
//cerr<<" Position : "<< pos<<" "<< pos/8<<" "<< pos%8<<" "<< bits.size();;

if(pos>nbits) {cerr<<" ERROR ";return -1;}

if(((pos-1)/8)< bits.size())
{
if (((bits[(pos-1)/8] >> (7-(pos-1)%8)) & 0x1) == 0x1)
return 1;
else
return 0;
}

pos=(pos)%8;
pos--;
//cerr<<" "<< pos<<" "<< tempsize<<" "<< temp[pos];
if(temp[pos]=='1') return 1; else return 0;
}

int PrintBits()
{
cerr<<" Printing Bits Index:"<< index<<" nBits:"<< nbits<<" ";
for (IntC i = 0; i < bits.size(); i++)
{
cerr<<(bits[i]>>7 & 0x1)<<(bits[i]>>6 & 0x1)<<(bits[i]>>5 & 0x1)<<(bits[i]
>>4 & 0x1)<<(bits[i]>>3 & 0x1)<<(bits[i]>>2 & 0x1)<<(bits[i]>>1 & 0x1)<<(bits[i] &
0x1);
}

for (IntC i = 0; i < tempsize; i++)
cerr<< temp[i];
return 1;
}

} BitHolder,*PBitHolder;

bool operator<(const BitHolder &a, const BitHolder &b)
{
//cerr<<"\n SORTING "<< a.index<<" "<< b.index;
IntC i,j;
for(i=0;i< a.bits.size();i++)
{
for(j=7;j>=0;j--)
{
//cerr<<"| i:"<< i<<" j:"<< j<<" "<<(a.bits[i] >> j & 0x1)<<" "<< (b.bits[
i] >> j & 0x1);
if(((a.bits[i] >> j & 0x1)==0x1)&&((b.bits[i] >> j & 0x1)==0x0))
return false;
if(((a.bits[i] >> j & 0x1)==0x0)&&((b.bits[i] >> j & 0x1)==0x1))
return true;
}
}

//cerr<<" Tempsize : "<< a.tempsize;
for(i=0;i< a.tempsize;i++)
{
if((a.temp[i]=='1')&&(b.temp[i]=='0'))
return false;
if((a.temp[i]=='0')&&(b.temp[i]=='1'))
return true;
}

return false;
}

bool operator==(const BitHolder &a, const BitHolder &b)
{if(((a< b)==false)&&((b< a)==false)) return true; else false;}

bool operator>(const BitHolder &a, const BitHolder &b)
{if (b < a) return true; else false;}

Random Distribution: Gaussian

2005-06-06T05:58:00.000-07:00

Some random number genertion codes for some distributions

// The state vector for generation of random numbers.
char rngState[256];

// Initialize the random number generator.
void initRandom(){
initstate(2, rngState, 256);
}

// Generate a random integer in the range [rangeStart,
// rangeEnd]. Inputs must satisfy: rangeStart <= rangeEnd.
IntC genRandomInt(IntC rangeStart, IntC rangeEnd){
if(!(rangeStart <= rangeEnd)) return -1;
IntC r;
r = rangeStart + (IntC)((rangeEnd - rangeStart + 1.0) * random() / (RAND_MAX + 1
.0));
return r;
}

// Generate a random 32-bits unsigned (Uns32C) in the range
// [rangeStart, rangeEnd]. Inputs must satisfy: rangeStart <=
// rangeEnd.
Uns32C genRandomUns32(Uns32C rangeStart, Uns32C rangeEnd){
Uns32C r;
if (RAND_MAX >= rangeEnd - rangeStart) {
r = rangeStart + (Uns32C)((rangeEnd - rangeStart + 1.0) * random() / (RAND_MAX
+ 1.0));
} else {
r = rangeStart + (Uns32C)((rangeEnd - rangeStart + 1.0) * ((LongUns64C)random(
) * ((LongUns64C)RAND_MAX + 1) + (LongUns64C)random()) / ((LongUns64C)RAND_MAX * (
(LongUns64C)RAND_MAX + 1) + (LongUns64C)RAND_MAX + 1.0));
}
return r;
}

// Generate a random real distributed uniformly in [rangeStart,
// rangeEnd]. Input must satisfy: rangeStart <= rangeEnd. The
// granularity of generated random reals is given by RAND_MAX.
RealC genUniformRandom(RealC rangeStart, RealC rangeEnd){
RealC r;
r = rangeStart + ((rangeEnd - rangeStart) * (RealC)random() / (RealC)RAND_MAX);
return r;
}

// Generate a random real from normal distribution N(0,1).
RealC genGaussianRandom(){
// Use Box-Muller transform to generate a point from normal
// distribution.
RealC x1, x2;
do{ x1 = genUniformRandom(0.0, 1.0); } while (x1 == 0); // cannot take log o
f 0.
x2 = genUniformRandom(0.0, 1.0);
RealC z;
z = SQRT(-2.0 * log(x1)) * COS(2.0 * M_PI * x2);
return z;
}

GetStore and Url Extraction

2005-06-06T05:57:00.000-07:00

Things to Note:
perl program can take out URL out of xml files,
getstore() can store the file at the given url

@lines= split(/ /,$line);

@url="";
@filenames="";

foreach $item (@lines)
{
if($item =~ /^URL*/)
{
$i=index($item,"\"");
$j=rindex($item,"\"");
push(@url,substr($item,$i+1,$j-$i-1));
}
}

foreach $item (@url)
{
print "\n ";
$i=rindex($item,"/");
$filename= substr($item,$i+1,length($item)-2-$i);
push(@filenames, $filename);
if( getstore($item,"$dir/$numg-$filename") < 400)
{$numg++;}
}

Magic Number in Perl

2005-06-06T05:54:00.000-07:00

A way to check for various image formats, the code is in perl. It checks the magic number for the image format

($in) = @ARGV;
die "Missing input file name.\n" unless $in;

$im = 0;
open(IN, "< $in");
binmode(IN);
read(IN,$b,4);
$s = 2*length($b);
$ch = unpack("H$s", $b);
print "\n |$ch| ";
if($ch eq "ffd8ffe0") {print " JPEG ";$im=1;}
if($ch eq "47494638") {print " GIF ";$im=1;}
if($ch eq "89504e47") {print " PNG ";$im=1;}
if($ch eq "4d4d002a") {print " TIFF Big Endian ";$im=1;}
if($ch eq "49492a00") {print " TIFF Little Endian ";$im=1;}
if($ch =~ /^424d/) {print " BMP ";$im=1;}
close(IN);

exit;

Windowmaker Themes

2005-03-31T06:19:00.000-08:00

To set themes in windowmaker type the command

setstyle aay.themed

but the particular folder should contain the style file for the theme. I found some cool themes at http://themes.freshmeat.net/browse/918/?topic_id=918 with style files in them. I don't know how to change the style with lsm file. Maybe if I find it soon enough I'll put it here.

OpenGl Makefile

2005-03-31T06:10:00.000-08:00

While doing Computer Graphics i spent a lot of time on a Makefile. I am putting a sample one here. Might help you some day ....
==============================================
CC=g++ -w -pg

GL_INC_DIR=/usr/include
GL_LIB_DIR=/usr/lib
X_LIB_DIR=/usr/X11R6/lib

GL_LIBS=-L$(GL_LIB_DIR) -lglut -lGLU -lGL
X_LIBS=-L$(X_LIB_DIR) -lXmu -lX11 -lXi

CFLAGS = -Wall

.PHONY:clean

OBJ = colorcube.o
LIBS = -L $(GL_LIB_DIR) $(GL_LIBS) $(X_LIBS)

all: $(OBJ) colorcube

$(OBJ): %.o : %.cpp
$(CC) -c $(CFLAGS) $< -o $@

colorcube: $(OBJ)
$(CC) $(OBJ) $(LIBS) -o $@

clean:
rm -f ./*~ ./core $(OBJ)

#DO NOT DELETE
colorcube.o : colorcube.h
===============================================

Command Prompt

2005-03-31T06:06:00.000-08:00

To customise your command prompt display add these lines into the end of your .bachrc
PS1="System-\h/\d/\t $ "
\h stands for host
\d stands for day
\t stands for time

This makes my display look like

System-kamod/Thu Mar 31/19:38:05 $

Unlocking in Use profile in Mozilla

2005-03-31T06:04:00.000-08:00

Many times when you logout of linux while using mozilla your profile remains 'in use'. An easy way to use it again is to go into .mozilla directory and in your profile folder and remove the file named 'lock' there.
cd .mozilla
cd Shubham
cd mbhht9k3.slt
rm lock

A guide into CSE

2005-03-31T05:58:00.000-08:00

While doing engineering at Computer Science and Engineering in IIT Delhi, it occurred to me that all the things on which I spend hours on the net searching can be put into once page. I am dedicating this page to all such things.
If you visit this and are reading this, hope you like it.