Slashdot Mirror

One of the labs in the university I graduated from also specialized in omnitreadmills. I heard they even had model capable of 3D(upstairs/uphill and downstairs/downhill) movements, which they showed on SIGGRAPH a few years ago.

here: http://www.biol.tsukuba.ac.jp/cbs/home1.html

• The Map Room from "The Cartographers" in Mike Resnick's Birthright: The Book of Man ;
• Star Trek's holodecks;
• Professor Xavier's Cerebro

Meanwhile, in the non-fictional realm, the VR Lab at the University of Tsukuba (Japan) has been working for years on "Ensphered Vision", complete with sound.

It's a Roland the Plogger story, so you know there has to be something wrong with it.

There have been a few previous attempts at 2D treadmills. They're usually just a big endless chain of belt-type treadmills, like this one. The problem is that the things are big, heavy, expensive, and may have pinch points.

Here's a paper which lists most of the previous omnidirectional treadmills. The Darken Omnidirectional Treadmill (1997) was a belt made of rollers. The Torus Treadmill was an array of 12 small treadmills on an endless chain. This new treadmill looks like a bigger version of the Torus Treadmill.

The Sarcos Treadport is a more aggressive approach to the problem. It's only a 1D treadmill, but it's on a tilt base, so it can simulate hills. The user is in a suspended harness which can yank the user around to simulate collision with an obstacle. (Now there's force feedback.)

So this isn't that novel; it's just a bit bigger. Typical Roland the Plogger; press release goes in, blogspam comes out.

And the time it takes to get something published is ridiculous ! Take the following example from http://hri.iit.tsukuba.ac.jp/tchri Important Dates: June 1, 2006: Call for Papers September 30, 2006: Deadline for Paper Submission February 28, 2007: Completion of First Review June 30, 2007: Completion of Final Review December 2007 (tentative): Publication So i get to wait 5 months until i known the article gets reviewed . If it's ok it gets published in 1.5 years after submission ?!?!?! If it doesn't get published i still lost 5 months with my work idleing, because i compromised to just publish to that journal ! In http://boost.org/ they peer review c++ libraries in 1 month tops ! I get to face the reviewers and reply their quesions, the reviewers are not anonymous also !

Direct link: http://sanlab.kz.tsukuba.ac.jp/HAL/indexE.html

This approach applied to paraplegia would go along way to re-humanizing people stuck in wheelchairs. Even more so than Dean Kamen's four/two wheel stabilized wheelchair.

http://sanlab.kz.tsukuba.ac.jp/indexE.html

http://www.time.com/time/business/article/0,8599,1 129522-5,00.html

'Mother'!?!? -- the Japanese already built HAL (http://sanlab.kz.tsukuba.ac.jp/HAL/indexE.html), and now they're working on that damndable computer from Alien too!?

CirculaFloor is a group of independent tiles that move in under the person so that they can walk without moving forward. It is actually increadible annoying to use because you can loose your balance easily in the VR environment as everything but your ears think you are moving forward when you are staying still. It also isn't fast enough yet to handle rapid changes in direction. However, I think it is a much better plan than a giant ball.

Now that you mention it, they call themselves Cyberdyne Corp. on the official webpage for an earlier model.

What's in a name... Combining the robotic suit with Space Odyssey moreless gives you The Wrong Trousers.
I cannot do that, Wallace...

Z

The video is available on this page:

http://intron.kz.tsukuba.ac.jp/vrlab_web/CirculaFl oor/CirculaFloor_e.htm

There are fundamental problems with all of these types of devices-- they 1) don't let the body handle momentum naturally and 2) don't stimulate the vestibular system in a way that is consistent with the visual or proprioceptive (the body's sense of where its limbs are) cues.

1) Momentum: On a 2-D treadmill, the omni-directional treadmill is supposedly fast enough that it allows for running. But when you are running and then change direction quickly, your body will lean into the turn to counter its momentum. Doing this on the treadmill will make you fall over. Someone once described it as "running on a slippery ice cube".

2) Vestibular cues: Our body can sense motion even without visuals or body movements. This is why some flight simulators have motion platforms [://www.simlabs.arc.nasa.gov/vms/motionb.html]. One post above said that the treadmill should reduce motion sickness because it provides body motions as well as visuals. But a treadmill doesn't cue the vestibular system. One theory of motion sickness is that it results from a mismatch of visual and vestibular cues. In the back seat of a car, your visual cues say you are still (relative to the inside of the car) but the vestibular system says you are moving. Similarly in a IMAX theater or while playing an FPS on a big screen, your visuals say you are moving but your vestibular system says you are still. Knowing how you are moving is critical for maintain balance and even surviving. The mismatch in visual and vestibular cues interferes with your ability to balance, and that's why dizziness results.

Luckily, one can fool the vestibular system, much as we can fool the visual system. Techniques include "wash-out" on motion platforms, electrical stimulation, and Redirection. Wash-out is where the motion platform moves the user to simulate the virtual motion, but then sneaks her back to the center of the room at an acceleration that is below what her vestibular system can detect. The shifting tiles look like a fabulous idea, and I wonder if one could implement a form of wash-out on those tiles.

Links

• Nasa Ames VMS motion simulator
• http://www.simlabs.arc.nasa.gov/vms/motionb.html

  Sphere http://www.vr-systems.ndtilda.co.uk/sphere1.htm2-D treadmills

  Omni directional treadmill http://www.movesinstitute.org/darken/publications/ ODT-UIST97.pdf

  Torus treadmill (great video) http://intron.kz.tsukuba.ac.jp/vrlab_web/torustrea dmill/torustreadmill_e.html

  Redirection http://www.cs.unc.edu/~eve/rdw/

One more thing, the problem with, as one post suggested, implementing VR in a huge wide open space (like a desert) is tracking. The computer needs to know where your head is and in which direction you are looking, very accurately and quickly, so it can draw the virtual scene from your perspective. By accurately, I mean with millimeter precision, and by quickly I mean it must update the images within tens of milliseconds of your head moving. If you focus your eyes on your figure at arms length, then rotate your head right and left, the reflex that moves your eyes to keep them locked on your finger is called the VOR (vestibular ocular reflex). It can react to head movements in 10 milliseconds.

http://intron.kz.tsukuba.ac.jp/vrlab_web/CirculaFl oor/circulafloor.mpg/

They do move!(admittedly hella slow). No dodging and rolling (or running or even walking at a normal pace) in this system, but it does look like a step in the right direction.

Um, no pun intended.

Not sure if anyone else pointed this out, but the actual website is here and includes a demonstration video.

• TOYOTA's Press Release
  
• TOYOTA PARTNER ROBOT Page(movie)
  
• Movie(WMP)
• Movie(Real)

Others Robotics sites

• TMSUK T-52(Movie)
• HAL(Hybrid Assistive Leg)
• Bipedal Locomotor WL-16

...and it's smaller to boot:
Hybrid Assistive Leg

This is due to the way C++ is generally taught [...]

I taught a university course on programming languages where we only had a few weeks for C++. The goal was to teach it for its own merits, not as an extension to C. The book "Accelerated C++" by Andrew Koenig and Barbara Moo was excellent. It uses the standard library from the beginning so you can do practical coding immediately. In particular, you get experience using templates and classes, before you need to create your own. Here's a good review of it.

More details here: original pdf, converted html.

You need to handle pointers and references, google for pointer swizzling. Garbage Collection by Richard Jones and Rafael D. Lins explains some of the issues involved. Alexei Andresceu's Modern C++ Design gives a sample implementation. This is one of the tasks that reflection, aspect-oriented programming or a meta object protocol makes easier, otherwise you need to add a .serialize() method to each object.

If you like the signals/slots idea of Qt and other such interesting extensions to the language, check out OpenC++ here. It lets you extend the C++ compiler in C++ (plus a little). ColdStore uses it to implement orthogonally persistent and runtime-introspectable classes by simply declaring a class as cold class foo instead of simply class foo. You can change damn near any aspect of the language, including adding extra member access declarations -- like "signals:" and "slots:"

MUCH cleaner than moc.
--

This guy has incredible "true" hacking skills. Whether it's cars, arcade boards, even designing a user-friendly gameboy cartridge reader... unfortunately, not all of his site is in English, and I think he only has hacks for cars he owns... He might be able to provide some good starting info though...

Why does nobody talk about uplifting elephants? At http://www.biol.tsukuba.ac.jp/~macer/bll/bll6.html :

Sympathy is also seen in other mammal species upon death, for example elephants will sometimes pick up the ivory or bones of a dead herd member, hold pieces in their trunks, and pass them around. Some return for many years to the spot where a relative died, touching the relics. It makes us ask whether they remember. Elephants are the only mammals with brains larger than humans, actually three times the mass.

Elephants don't presently do much we regard as intelligent, and the absence of hands with opposable thumbs obviously doesn't help. Our understanding of their vocalizations is pretty minimal. Like whales, they may be conveying a lot of information that we are missing. There might be a good distributed.net project in there somewhere.

If somebody invented guns and radios that could be carried and operated by elephants, it would be interesting to see what armed, coordinated elephants would do to poachers. If there were elephant-operable construction machinery, they might build dwellings for themselves. Or maybe they'd have philosophical reasons for not doing these things. It would be interesting to know.

• Australiasia
  
  • Japan
    
    
  • ftp://ftp.netlab.is.tsukuba.ac.jp/pub /XFree86
  • ftp://ftp.iij.ad.jp/pub/X/XFree86
  
  
• Korea
  
  • ftp://ftp.kreonet.re.kr/pub/Linux/xfree86
  
  
• Australia
  
  • ftp://mirror.aarnet.edu.au/pub/XFree86
    
  • ftp://x.physics.usyd.edu.au/pub/XFree86
  
  

US

• ftp://phyppro1.phy.bnl.gov/pub/XFree86
  
• ftp://ftp.rge.com/pub/X/XFree86
• ftp://ftp.varesearch.com/pub/mirrors/x free86
• ftp://ftp.infomagic.com/pub/mirrors/XFr ee86
• ftp://ftp.calderasystems.com/pub/m irrors/xfree86
• ftp://ftp.cs.umn.edu/pub/XFree86
• 
  ftp://ftp.kernel.org/pub/mirrors/xfree86
  
  

Europe

• Austria
  
  • ftp://gd.tuwien.ac.at/hci/X11/XFree86
    
    
  
  
• Finland
  • ftp://ftp.funet.fi/pub/X11/XFree86
• France
  • ftp://ftp.lip6.fr/pub/X11/XFree86
  
  
• Germany
  • ftp://ftp.gwdg.de/pub/xfree86/XFree86
    
  • ftp://ftp.cs.tu-berlin.de/pub/X/XFree86
• Italy
  • ftp://ftp.unina.it/pub/XFree86
• Norway
  • ftp://sunsite.uio.no/pub/XFree86
  
  
• United Kingdom
  • ftp://sunsite.doc.ic.ac.uk/packages/XFr ee86

I hate the name "Metaobject Protocall" (MOP). It sounds academic - not something that a working programmer would ever make use of. I would like to (briefly) describe what a MOP is and why it is useful.

A MOP opens up a compiler in controlled ways. You define call-back functions that will be called when the compiler recognizes certain constructs - like defining a member function, assigning to a class, or using a class in an expression (like vector a+b). There will also be ways of finding and changing a class's members and base classes. The way you define these callbacks, is through metaclasses. It's easy, but not really that important for this brief introduction (see OpenC++). A not-so-bad way to think of a MOP is as the builder pattern.

That's the mile high view. Now, what can we do with it.

• Before/after methods. Originally, Stroustrup had before/after methods in C++ (he took them out after he found he was the only one making use of them). Before/after methods could be defined for functions so when the function was called its before method would be called first, and when the method returned, its after method would be called. This was useful for locking and unlocking semaphores (for example). Now, with a MOP, this is easy to implement. Everytime a method is called, we can use our hook into the compiler to insert a call to our before method and after method.
  
• Delegation. The decorator pattern uses delegation as its implementation. Consider a graphics class hierarchy: class Graphic; class GraphicDecorator : public Graphic. GraphicDecorator has a data member of type Graphic*. It needs to forward all of its function call to its contained graphic. This is straight-forward, but error prone. If we add a new function to Graphic, we need to remember to add it to GraphicDecorator as well. With a MOP, we can automatically build an class that delegates its function calls.
  
• Mulidispatch. I built code that does double-dispatch for C++ (for the visitor pattern). The implementation to make the function call was pretty straight forward: some tables of pointers to members that are indexed by the parameters (a virtual function call on the parameters to get the correct index). While the code to make the call was easy, building the tables was not. To build the tables, I needed to know and the inheritance tree. While the compiler knew this, I couldn't get at it. So I had to build code to automatically create this information at "static initialization" time (I don't know the correct term). This was especially challenging because of static initialization ordering problems. With a MOP I can directly access the inheritance tree. I don't have to build it myself. As a side note, Stroustrup did consider putting multidispatch into C++, but decided against it because it required too complex a linker.
  
• Optimizing vector/matrix classes. If you know about metatemplate programming (see blitz), you know you have to write some very complex code to optimize linear algebra code. With a MOP, you can use the hook to translate expressions to do these optimizations much more sanely.
• Object persistence. If you want to use pointer swizzling to implement object persistence, you need to know where the pointers are on a given page. With a MOP, you can find the layout of an object and keep track of where the pointers are on a memory page.
• Writing browsers.
• Writing "bridge" code to interface C++ with other languages, like Python.

I hope this gives you a taste of why I'm excited about MOPs. I haven't written much code using MOPs (I certainly don't claim to be an expert), and I'm not sure its ready for prime time yet, but I'd love to hear Stroustrup's view on this.

-Scott

Metaobject protocalls, like the one in OpenC++ is a nice way to handle the optimizations that template metaprogramming gives.

I've been playing around with OpenC++, C++ with a metaobject protocol and I find opening up the compiler in controlled ways like this to be very powerful - and more than just an academic toy. It would allow me to extend C++ in interesting ways to include Delegation (useful for the "Decorator" pattern) and multi-dispatch (useful for the "Visitor" pattern) - along with other interesting extensions (before/after methods, persistance, etc.). I know you considered and rejected both of these features in C++ (if I remember from "Design and Evolution of C++" you rejected Delegation because users found it confusing and you rejected multi-dispatch because it required too complex a linker[1]). I am not questioning your rejection of these features, but I would be interested in your option of a metaobject protocol for C++, which would allow me to add features like these to C++ so it is a closer to my designs. Did you consider a metaobject protocol for C++, and if you did why did you rejected it (too immature? too hard to maintain code? not useful enough to justify the complexity to the language?)

-Scott
nonya_cpp_question@yahoo.com

[1] I should mention my version of Multi-Dispatch doesn't solve the linker problem, it requires you call a function at the start of a program to initialize some tables of pointers to member functions.

I do note that IBM has VisualAge COBOL, but where are the Qt bindings?

... And when will you be putting fixed-record support into ext2?

Which one of the COBOL environments provides a metaobject protocol? (Just as CLOS - Common Lisp Object System has, as does C++ as does Guile with GOOPS

Hmm? Hmm? Inquiring minds want to know...

At worse, they should use OpenC++, and generate pure "C" non-class code from class code.

An alternative is to define a bootstrap language in Lisp and write everything from in. Then automatically generate C code (or C++, Java, Eiffel... code (or all of them)). This is how real programmers do it.

Years of language research, and stil that... sigh...

A good language makes it easier for the programmer to specify parallelism and easier for the compiler to exploit the parallelism, but in the end, it is a matter of program design (and I wouldn't hope for a significant change of this situation in the near future).

Chilli

PS: I happen to know, as I have written a PhD thesis and a number of research papers in this area. (You can get the stuff from my Web page, if you are interested. There is also a compiler project targeting massively parallel systems.)