OT: invisibility cloak

just a random idea from a few days ago, maybe interesting...

---
well, just me sitting around here, and having a few more thoughts related to
how to make a sort of "cloaking device" at least hypothetically.


mostly, my idea is based on a prior idea of mine, but involves a few
simplifications in the design, which could potentially make it more
"practical" to build.

my idea does not involve any meta-materials or other "fancy science",
basically, mostly stuff that already works, and has established commercial
use.


the basic design is essentially an elaborate variation of an OLED display,
however:
beyond the OLED layer, would be a "lensing layer";
essentially, this would be a massive number of tiny lenses, and working in a
manner similar to a lenticular hologram (AKA: the cheap holograms usually
printed on labels/...).

http://en.wikipedia.org/wiki/Lenticular_printing
http://en.wikipedia.org/wiki/Lenticular_lens

so, basically, this is the first part of the idea:
you have essentially a really big and flexible lenticular display (this part
is important, so then it can be wrapped around a wearer, or with slight
adaptations, could be made into a type of suit).


the next part of the idea is this:
how do you get the image to display on the suit?


I have also made another recent discovery of some relevance here:
if people run LEDs or OLEDs in reverse (AKA: reverse the voltage), then they
work as photoresistors. even more useful is that they are sensitive to more
or less the same part of the light spectrum that they emit.

now, back to the lenticular layer:
this will serve a dual purpose, as not only will it serve to make the image
3D, but it will also work as a mass of tiny camera lenses.

this means that by regularly changing the direction of the voltage, using
part of the cycle for emission, and part of the cycle for reading, it will
be possible to use the entire surface as both a display and as a camera (if
you were to feed the input back to the output, it would work like a
mirror...).

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


so, now 2 parts of the process are covered.

the next part of the problem:
knowing the "shape" of the surface.


however, I have discovered something useful here as well:
it is possible to use fiber-optic cable to measure flex (apparently, this is
done in many VR gloves);
namely, the more straight the cable is, the more light goes through, and the
more bent it is, the less light goes through.

this mixes in very nicely with a dual-purpose camera/display setup (which
already serves to finely emit and measure light). in effect, we can utilize
otherwise "dead" areas of pixels for the flex sensors.

in this case, we wouldn't be using actual fiber-optic cables (as in glass),
but rather it would be possible to make another layer (essentailly a
substrate) which would contain a large number of transparent plastic
channels serving essentially the same purpose. this would form a lattice
underneath the display, which would essentially read in the flex-data at the
same time the image is read (the substrate would be otherwise black, and
these spots on the lensing layer would be similarly darkened, such that flex
pixels only see "internal" light).

the rest of the substrate would likely be a dark insulating rubber-like
material (both for thermal concealment, as well as for durability, possibly
in combination with a layer of cloth).


the electronics would basically be similar to what would be found in an OLED
display and a digital camera, only that the CCD would be the display.

note that by alternating the polarity of the pixels, it would also be
possible to both capture and display an image at the same time (similar to
video interlacing, where at any given moment, 50% are displaying and 50% are
capturing), which could be very useful in things like allowing the suit to
self-calibrate, ... as well as allowing more flexibility for things like
flex-sensing/...


the whole rest of the process would be done in software (I had thought some
about what math would be required to turn all this into "invisibility").

actually, I suspect that most of the process could probably be done in
real-time using a combination of image processing and pixel shaders (or,
possible, even in real-time without the use of a GPU, depending on factors
like resolution and processor speed).


basically, the first pass would be to convert the flex-data into a vector
map (basically, converting all of the data in the input image into a
deformed spatial representation).

this would work by assuming one of the corners were at a fixed location and
orientation, and essentially using a process similar to inverse linear
filtering (note: in you know how the PNG format works, it is a similar
idea).

so, a simple O(n) process converts the flex-map into a vector map,
essentially allowing nearly per-pixel spatial positioning. similarly, it is
not difficult (knowing the mathematical properties of the lensing surface)
to calculate a normal vector for every pixel in the image.

with this much information, several other things can be done:
we know the 3D/optical layout of the surroundings (theoretically, using a
little more image processing, we could fairly easily produce a solid 3D
mapping of the surrounding environment as well)

in much the same way, through the powers of line-tracing and dot product, it
is possible to calculate the output light level for every spot on the
surface. this itself would be an O(n) process (in general), but does involve
the cost of finding the matching spot on the input surface (could be
expensive, although forming a polygonal approximation and using a BSP tree
could greatly optimize this).

the overall "redraw" would thus take about O(n log2 m) time (where n is
pixels, and m is the number of tesselated polygons). a very much "simpler"
redraw algo could also work in O(n^2) time (basically by using a variant of
radiosity), but this would likely be unacceptably slow (instead, we would
trace a line, and use a vaguely radiosity-like approach for a small patch of
pixels at a time...).



a little bit of internal trickery could reduce graphical issues related to
things like folds like folds/...

this would involve making the suit "feedback sensitive", and initially the
suit would likely need a "calibration" stage (basically, this would be like
when first turning on a video camera, and it needs to normalize the light
level and color, at which point the wearer would be "becomming
invisible"...)..

additionally, by making the suit detect and emit IR and UV (as well as
visible light), and by limiting "black body radiation" in the substrate, it
should also be possible to (more or less) hide the user's thermal pattern as
well, and with a high-enough dynamic range in the output, the user's shadow
should also be (mostly) hidden.

also by using suit-feedback, it should also be possible to both hide
internal folds in the suit, as well as allowing the user to wrap around
external objects without obscruring them (AKA: a user wrapped around a pole
will not hide this section of pole). this would be done mostly be using a
pass over the image using internal feedback to calculate alpha and other
factors (a segment with low alpha, such as an internal fold, would be
essentially ignored).


but, yeah, maybe all this is interesting...

or such...


--
BGB: Hobbyist Programmer (Specialty: 3D, Compilers, VMs)
Site: http://cr88192.dyndns.org/


--
BGB: Hobbyist Programmer (Specialty: 3D, Compilers, VMs)
Site: http://cr88192.dyndns.org/


.