Related posts:

1. First attempt at panorama.
2. First attempt at panorama.

Related posts:

1. Canon EOS 550D
2. morning route to work

Here is an example of what the code generates:

This is example terrain was generated in about 2 second.

Here is the code:

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;

namespace TankersTD.Tankers.Tools
{
    class TerrainGenerator
    {
        private double initFrequency, initAmplitude, persistance;
        private int octaves, seed;

        public Texture2D generateTerrain(GraphicsDevice gd,
                int width, int height, double ammountofearth,
                double initFrequency, double initAmplitude, double persistance, int octaves )
		{
			this.initFrequency	= initFrequency;
			this.initAmplitude	= initAmplitude;
			this.persistance	= persistance;
			this.octaves		= octaves;

            seed = System.DateTime.Now.Millisecond;

            Texture2D result = new Texture2D(gd, width, height);
            Color[] cData = new Color[width * height];

            int t_he = 1, t_wi = 1;
            for (int x = 1; x < width*height; x++)
            {
                if (t_wi > width)
                {
                    t_he++;
                    t_wi = 1;
                }
                double val = Function2D((double)t_wi, (double)t_he);
                if (val > (ammountofearth*-1))
                    cData[x] = Color.Black;
                t_wi++;
            }

            result.SetData(cData);
            return result;
        }

        // returns the Perlin Noise value for the given coordinate
        private double Function2D(double x, double y)
		{
			double	frequency = initFrequency;
			double	amplitude = initAmplitude;
			double	sum = 0;
			for ( int i = 0; i < octaves; i++ )
			{
				sum += SmoothedNoise( x * frequency, y * frequency ) * amplitude;

				frequency *= 2;
				amplitude *= persistance;
			}
			return sum;
		}

		private double Noise( int x, int y )
		{
			int n = x + y * 57;
			n = ( n << 13 ) ^ n ;
            return (1.0 - ((n * (n * n * (15731 + seed) + 789221- seed) + 1376312589) &amp;amp;amp; 0x7fffffff) / 1073741824.0);
		}

		private double SmoothedNoise( double x, double y )
		{
			int		xInt = (int) x;
			int		yInt = (int) y;
			double	xFrac = x - xInt;
			double	yFrac = y - yInt;
			double	x0y0 = Noise( xInt    , yInt );
			double	x1y0 = Noise( xInt + 1, yInt );
			double	x0y1 = Noise( xInt    , yInt + 1 );
			double	x1y1 = Noise( xInt + 1, yInt + 1) ;
			double	v1 = CosineInterpolate( x0y0, x1y0, xFrac );
			double	v2 = CosineInterpolate( x0y1, x1y1, xFrac );
			return CosineInterpolate( v1, v2, yFrac );
		}

		private double CosineInterpolate( double x1, double x2, double a )
		{
			double f = ( 1 - Math.Cos( a * Math.PI ) ) * 0.5;
			return x1 * ( 1 - f ) + x2 * f;
		}
    }
}

The code is used like this (the picture above was generated using these input variables):

TerrainGenerator terraingenerator = new TerrainGenerator();
Texture2D ter = terraingenerator.generateTerrain(
        graphics.GraphicsDevice, 2048, 1024, -0.1, 0.0225, .5, 0.05, 1);

Related posts:

1. Project: Blinky – Sound Level Warning

A concern we had with the new office was that the background noise would be quite loud when everyone is talking on the phone and conversing between each other.  We diden’t want to divide the room into smaller sections so one solution we had to this problem was to buy some sort of decibel detecting device that would warn when the sound level got too high. Unfortuately those devices are hard to find and quite expensive so I instead set out to see if I could build a cheap but just as good detector myself.

Here is a video of the result:

There were three problems to solve in order to get this to work.

(1) Sound Detection – How loud is it, and when is it to loud.
(2) Controll - some sort of switch board to open or close a channel when sound is to loud.
(3) Warning – Making the switch board turn on a stroboscope.

Problem (1), Sound Detection.

To analyze the sound in the office I thought I would use one of the old laptops which noone uses anymore and build a program which would read input from a microphone and create some sort of average of the current sound levels. I started building this in C# .net 4.0 and it turned out pretty good.

I used NAudio to read a byte[] from the microphone and then analyzed this data to see how “loud” the sound is.

Here is a screenshot of the program:

The top green bar moves back and forth as sound decreases or increases. If the bar goes past the red line then the sound is to loud. Two of the three sliders are used to calibrate when this happens.

“Smoothing” is used to tell the program how sensitive it should be, the farther to the left the slider is the more sensitive it is to sudden changes in sound levels.

“Multiply” is used to set the detection level of the program, slide this back and forth untill the measuring bar responds to noise as you want and dosen’t spike for every sound you make. This is basically how much the program should multiply the input that it is reading from the microphone.

The final slider, “Blinky Time”, is just a setting to tell the program how long it should let the blinker stay on once noise has gone below the limit again.

The complete Visual Studio 2010 Project is linked at the bottom, but here is the code for just the sound detection:

using System;
using NAudio.Wave;
using NAudio.Midi;
using System.Collections;

namespace Volumizer
{
    class SoundController
    {
        private WaveIn waveInStream;
        private double average;
        public SoundController()
        {
            waveInStream = new WaveIn();
            waveInStream.BufferMillisconds = 10; // Mic polling intervall
            waveInStream.DataAvailable +=
                    new EventHandler<WaveInEventArgs>(waveInStream_DataAvailable);
        }
        void waveInStream_DataAvailable(object sender, WaveInEventArgs e)
        {
            byte[] _buffer = e.Buffer;
            int skipnum = 4; // dont need to read every byte of data
                             // skip a few bytes to speed it up.
            double sum = 0;
            for (var i = 0; i < _buffer.Length; i = i + 2 + skipnum )
            {
                double sample = BitConverter.ToInt16(_buffer, i) / 32768.0;
                sum += (sample * sample);
            }
            double rms = Math.Sqrt(sum / _buffer.Length / skipnum );
            var decibel = 20 * Math.Log10(rms);
            average = decibel;
        }
        public double getSoundLevel()
        {
            return average;
        }
        public void startMeasuring()
        {
            waveInStream.StartRecording();
        }
        public void stopMeasuring()
        {
            waveInStream.StopRecording();
            waveInStream = null;
        }

    }
}

Problem (2), Controlling some sort of output / switchboard

There are a number of controller boards which can be connected and controlled though a USB port, I used a Velleman K8055. I chose this board mostly because it was available on short notice in an electronics store near me, if you have more patience you could check out Pololu and probably spend a little less money.

The nice thing about the K8055 is that it is easily controlled though C# using the included SDK / DLL.
To turn on a digital output (i.e. turn the light switch on or off) all you need to do is import the functions from the included dll file:

[DllImport("k8055d.dll")]
public static extern void SetDigitalChannel(int Channel);

[DllImport("k8055d.dll")]
public static extern void ClearDigitalChannel(int Channel);

I then made the program call these functions based on if the sound was to loud or not.

Problem (3), Relays and Stroboscopes

The digital output on the cirtuitboard has a maximum throughput of 50V/100mA so instead of connecting the warning light directly to the board I used the board to power a relay which in turned powered my warning light, that way there’s no risk of putting to much power through the circuits.

Here are a few pictures of it (and yes, I used a small lunchbox to protect the electronics ):

Good luck making your own!

Related posts:

1. my office & Haldex Run