I wrote a small program in flash which took some of the points mentioned in the book on population growth - which incidentally can be compared to bacterial growth and many of the shapes produced on a large scale are very similar! These similarities can be explained by a process called emergence, whereby complex patterns - for example the shape of a city - can arise from simple mathematical rules - for example people prefer to live near water. To the right is a nice image showing some outcomes of emergence.
CAM.setQuality(0, 100);
CAM.setMode(550, 400, stage.frameRate );
var VIDEO:Video = new Video(550, 400);
VIDEO.attachCamera(CAM);
addChild(VIDEO);
So lets add an event listener to the stage for when a user clicks on the image, this will later invoke the function to save the image.
stage.addEventListener(MouseEvent.MOUSE_DOWN, save);
function save(e:MouseEvent):void
{
}
The tool I use to encode image data is called AS3 core lib. This tool has a load of classes but the one we want to use is called JPGEncoder.as, and you can download it here.
So lets import that into our movie. First create a folder, call it "com" and drag your newly acquired file into it. This folder should be in the same directory as you .fla and .swf files. Above all of the other code on the first frame write the following:
var jpg_encoder:JPGEncoder = new JPGEncoder(100);
This initiates the class and sets the jpg output quality to 100. Of course if you want to output low quality jpegs you could always change this to 50 or something else.
So we have the jpeg encoder, what this does is converts bitmap data into a byte array which your computer will be able to read as a file. So next we'll create a bitmap, this should have the same resolution as your webcam stream (in this case 550x400).
var bitmap:BitmapData(550,400);
Now, within the save function lets draw the VIDEO object into the bitmap data using the draw() function
bitmap.draw(VIDEO);
If you read my previous post on saving from flash you'll already know exactly how to save files, just in case you missed it here it is -
1) Create a file reference object:fileToSave:FileReference = new FileReference();
2) In your save function encode the jpeg data, we'll use the ByteArray class...
var bytes:ByteArray = jpg_encoder.encode(bitmap);
3) and finally just after that within the save function
fileToSave.save(bytes,"screenshot"+".jpg");
The parameters are data and name, the data being the encoded jpeg and in this case the name is "screenshot.jpg". Note you'll need the extension for your computer to recognise the data as an image.
So here is an example, take a little snap of yourself from your webcam. (The whole file is only 8kb!)
Enjoy guys!
var CAM:Camera = Camera.getCamera();
CAM.setQuality(0, 100);
CAM.setMode(550, 400, stage.frameRate );
var VIDEO:Video = new Video(550, 400);
VIDEO.attachCamera(CAM);
addChild(VIDEO);var CAM:Camera = Camera.getCamera();CAM.setQuality(0, 100);
CAM.setMode(550, 400, stage.frameRate );var VIDEO:Video = new Video(550, 400);
VIDEO.attachCamera(CAM);addChild(VIDEO);
<link type="text/css" href="css/dot-luv/jquery-ui-1.7.2.custom.css" rel="stylesheet" />
<script type="text/javascript" src="js/jquery-1.3.2.min.js"></script>
<script type="text/javascript" src="js/jquery-ui-1.7.2.custom.min.js"></script><script type="text/javascript">
$(function()
{
// Tabs
$('#tabs').tabs();
}
</script>
And finally the actually object needs to be placed in your page:<div id="tabs">
<ul>
<li> <a href="#tabs-1">Tab 1</a> </li>
<li><a href="#tabs-2">Tab 2</a></li>
<li><a href="#tabs-3">Tab 3</a></li>
</ul>
<div id="tabs-1">I am tab 1's content</div>
<div id="tabs-2">I am tab 2's content</div>
<div id="tabs-3">I am tab 3's content</div>
</div>
As you can see all of the content is loaded into seperate divs, one for each tab!
Understanding the nature of the colours present in light is a vital part of this project. Light has an additive nature, unlike pigments, which have a subtractive nature. This means that increasing proportions of red, green, and blue light result in
the formation of white light, and various combinations of those colours can form every colour in the visible spectrum.
Due to their ability to produce such a vast array of hues they also form the basis for colour formation in standard computer monitors, televisions and other liquid crystal displays. Technically the choice of red, green and blue are not exact, they are chosen due in large part to the sensitivities of the cone cells in the rear of the retina. Differences in the hues of the red, green and blue constituents chosen may produce different absolute colour spaces, for example sRGB and Apple RGB are two absolute colour spaces used in computer monitors. In computing terms the R, G, B value of a colour represents its red, green and blue components proportionally, normally each on a scale of 0-255 (This requires three 8-bit values). For various other purposes in computer graphics a further two bits per unit may be added, for example RGBA includes information about the alpha channel (transparency) of a pixel, and contains three 10-bit units of colour per pixel. In the case of visible light however only the RGB values, and their associated intensities need to be taken into account.
Since the LDRs that will be used in the colour detector have little or no wavelength dependence it is necessary to use colour filters to determine which wavelengths of light are hitting which detector and in what proportions. Colour filters work by transmitting certain wavelengths of light and reflecting or destroying through interference, the other wavelengths. Manufacturers often produce filters that allow not only the target colours wavelengths through. The effect of this is is often to brighten up the filters, by letting through more light.
A problem with this is that it is practically impossible to determine the exact chromaticities of the filter. A solution to this involves measuring intensities of pure red, green and blue light after they pass through the filter when compared to the intensities before transmission. By creating a transformation matrix from one set of colours to the other and inverting that matrix, a transform will be created to convert measured intensities (post filter) to the original colour of light (pre filter).
Since an optical interface is being used which can only transfer data digitally there is no way of transferring the 3 analogue voltage values directly to the computer. The PIC is used to sample the 3 values, store them, and then convert them into a form which is analysable by the PC. The way chosen to do this was to take a voltage value (in 8-bit so between 0 and 255), and a time delay proportional to this which turned the output port either on or off after each delay. The code snippet below shows how this was achieved although full code for all programs used in the project can be found in the appendices.
//liner delay subroutine (0xFF times input variable);
a equ 0x45
b equ 0x46
delay movwf a
movlw 0xFF
movwf b
ca movwf b
cb decfszb
goto cb
decfsz a
goto ca
return
The delay loop assumes that the voltage value has previously been stored in a. When the loop is called the embedded loop repeats 256a times, creating a time delay proportional to a. By turning the output port on and off, before and after the loop is called, a square wave output of voltage can be created with a period proportional to the input voltage.
movlw b'00000001'
movwf PORTB
// then call the delay loop
movlw b'00000000'
movwf PORTB
This can be repeated 3 times for each of the measured values, resulting in three flashes. The timed pulses will then be sent optically to the computer.
For documentation on how to program your PIC or other microchip I recommend visiting the manufacturers website at http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=64
So the image to the right is pretty much a summary of the whole system from
LDR to PIC to LED. After this stage the 3 flashes and their corresponding delays (how long they are on/off for) is sent to the computer via an optical to digital converter.
The final step was to write some software in C (as well as a codec for the optical to digital converter), to output RGB values and display something nice on the screen, in this case a blue LED is being shone onto the LDRs.
var previous:Point = (0,0);
var tx:Number = 0;
var ty:Number = 0;
tx = current.x;
ty = current.y;
current.x += (current.x - previous.x + F)*R
current.y += (current.y - previous.y + F)*R
previous.x = tx;
previous.y = ty;
I'm currently building a new game, so I thought I'd blog at each stage of the way. The game I'm working on is called Buzz and its a game about bees. You control a swarm of bees as they fly around levels trying to pollinate flowers as quickly as possible. I decided to write this game after hearing about colony collapse disorder - a relatively new term given to the phenomenon where bees abandon their hives. The disorder only effects honey bees