looking for ideas on generating RGB colors from accelerometer + gyroscope

	// convert these 16 bit signed integers to something we can make colors out of

	// raw values can be positive or negative, depending on which direction 
	// the axis is going. Let's use the same color for the same force in both 

	// turn into positive-only value, as we can't generate negative colors.
	// accelero values
	uint16_t ax_abs = abs(ax);
	uint16_t ay_abs = abs(ay);
	uint16_t az_abs = abs(az);
	// gyro values
	uint16_t gx_abs = abs(gx);
	uint16_t gy_abs = abs(gy);
	uint16_t gz_abs = abs(gz);

        // we scale down to 8 bit numbers, as the 3 colors are 8 bits each.
	if (gyro) {
		red_uint8 = gx_abs / 128;
		green_uint8 = gy_abs / 128;
		blue_uint8 = gz_abs / 128;
	} else {
		red_uint8 = ax_abs / 128;
		green_uint8 = ay_abs / 128;
		blue_uint8 = az_abs / 128;
	}

	*red = red_uint8;
	*green = green_uint8;
	*blue = blue_uint8;

	// cancel out some noise
	*red < 4 ? *red = 0 : 1 ;
	*green < 4 ? *green = 0 : 1 ;
	*blue < 4 ? *blue = 0 : 1 ;

long avg_value;
loop{
// add the new value to the moving average
avg_value = ( ( avg_value * 4 ) + new_value ) / 5
}

/*
  Color.h - Library for controlling RGB arcade buttons
  Created by Jesse R. Castro 2013-02-03
*/
#ifndef Color_h
#define Color_h

#include "Arduino.h"
#include <Common.h>

class Color
{
  public:
	//public vars
	
    //constructor
	Color(float pHue, float pSaturation, float pValue);
	Color(const Color& pColor);
        Color();
    //destructor
	
	//setters
	void setHue(float pHue);
	void setSaturation(float pSaturation);
	void setValue(float pValue);
	void setHSV(float pHue, float pSaturation, float pValue);
	//getters
	float getHue() const;
	float getSaturation() const;
	float getValue() const;
	int getRed();
	int getBlue();
	int getGreen();
	//action methods
	void turnOff();	
	//operator overloads
	Color& operator=(const Color &pColor);
	bool operator==(const Color &pColor) const;
	bool operator!=(const Color &pColor) const;
private:
    //private vars
	int red;
	int green;
	int blue;
	float hue;
	float saturation;
	float value;
	//setters
	void setRed(int pRed);
    void setGreen(int pGreen);
	void setBlue(int pBlue);
	void setRGB(int pRed, int pBlue, int pGreen);
	//getters
	
	//action methods
	
	//utilities
	void rgb2hsv();
	void hsv2rgb();
	float getMin();
	float getMax();
	int floor(float target);
};

#endif

/*
  Color.cpp - Library for controlling RGB arcade buttons
  Created by Jesse R. Castro 2013-02-03
*/

#include "Color.h"

Color::Color(float pHue, float pSaturation, float pValue){
	setHSV(pHue, pSaturation, pValue);
}
Color::Color(const Color& pColor){
	*this = pColor;
}
Color::Color(){
	setHSV(0,0,0);
}
//setters
void Color::setHue(float pHue){
	//Note, of these hue cycles, so we have to make sure that works
	//abs gets rid of any negatives
	//the val - floor(val) will take return only decimal portions
	hue = abs(pHue) - floor(abs(pHue));
	
}
void Color::setSaturation(float pSaturation){
	if(pSaturation < 0){
		saturation = 0;
	}else if(pSaturation > 1){
		saturation = 1;
	}else{
		saturation = pSaturation;
	}
}
void Color::setValue(float pValue){
	if(pValue < 0){
		value = 0;
	}else if(pValue > 1){
		value = 1;
	}else{
		value = pValue;
	}
}
void Color::setHSV(float pHue, float pSaturation, float pValue){
	setHue(pHue);
	setSaturation(pSaturation);
	setValue(pValue);
}
void Color::setRed(int pRed){
	if(pRed < 0){
		red = 0;
	}else if(pRed > 255){
		red = 255;
	}else{
		red = pRed;
	}
}
void Color::setBlue(int pBlue){
	if(pBlue < 0){
		blue = 0;
	}else if(pBlue > 255){
		blue = 255;
	}else{
		blue = pBlue;
	}
}
void Color::setGreen(int pGreen){
	if(pGreen < 0){
		green = 0;
	}else if(pGreen > 255){
		green = 255;
	}else{
		green = pGreen;
	}
}
void Color::setRGB(int pRed, int pGreen, int pBlue){
	setRed(pRed);
	setGreen(pGreen);
	setBlue(pBlue);
}
//getters
float Color::getHue() const{
	return hue;
}
float Color::getSaturation() const{
	return saturation;
}
float Color::getValue() const{
	return value;
}
int Color::getRed(){
	hsv2rgb();
	return red;
}
int Color::getGreen(){
	hsv2rgb();
	return green;
}
int Color::getBlue(){
	hsv2rgb();
	return blue;
}

//action methods
void Color::turnOff(){
	setValue(0);
}
void Color::rgb2hsv(){
	float r = (red + 0)/255.0;
	float g = (green + 0)/255.0; 
	float b = (blue + 0)/255.0;
			
	float max = max(max(r, g), b);
	float min = min(min(r, g), b);
	
	float h = max;
	float s = max;
	float v = max;

	float d = max - min;
	s = max == 0 ? 0 : d / max;

	if(max == min){
		h = 0; // achromatic
	}else{
		if(max == r){
			h = (g - b) / d + (g < b ? 6 : 0);
		}else if (max == g){
			h = (b - r) / d + 2; 
		}else{
			h = (r - g) / d + 4; 
		}
		h /= 6;
	}

	setHue(h);
	setSaturation(s);
	setValue(v);
}
void Color::hsv2rgb(){
	float r, g, b;

	float h = hue;
	float s = saturation;
	float v = value;
	
	int i = floor(h * 6);	
	float f = h * 6 - i;
	float p = v * (1 - s);
	float q = v * (1 - f * s);
	float t = v * (1 - (1 - f) * s);

	switch(i % 6){
		case 0: r = v, g = t, b = p; break;
		case 1: r = q, g = v, b = p; break;
		case 2: r = p, g = v, b = t; break;
		case 3: r = p, g = q, b = v; break;
		case 4: r = t, g = p, b = v; break;
		case 5: r = v, g = p, b = q; break;
	}

	setRed(round(r*255));
	setGreen(round(g*255));
	setBlue(round(b*255));
	
}
float Color::getMin(){
	float r = (red + 0)/255.0;
	float g = (green + 0)/255.0;
	float b = (blue + 0)/255.0;
	
	if(r < g){
		if(r < b){
			return r;
		}else{
			return b;
		}
	}else{
		if(g < b){
			return g;
		}else{
			return b;
		}
	}
}
float Color::getMax(){
	float r = (red + 0)/255.0;
	float g = (green + 0)/255.0;
	float b = (blue + 0)/255.0;
	
	if(r > g){
		if(r > b){
			return r;
		}else{
			return b;
		}
	}else{
		if(g > b){
			return g;
		}else{
			return b;
		}
	}
}
int Color::floor(float target){
	int returnVal = round(target);
	if(returnVal > target){
		returnVal--;
	}
	return returnVal;
}
//operator overloads
Color& Color::operator=(const Color &pColor){
	setHSV(pColor.hue, pColor.saturation, pColor.value);	
	return *this;
}

/** 
 * Comparison == operator overload.
 * @author Jesse R. Castro
 * @param pFoo An instance of the same type as this object.
 * @return A boolean value describing whether the objects are equivalent or not.
 */
bool Color::operator==(const Color &pColor) const {
	if(
		(hue == pColor.hue) &&
		(saturation == pColor.saturation) &&
		(value == pColor.value)
	){
		return true;
	}else{
		return false;
	}
}
/** 
 * Comparison != operator overload.
 * @author Jesse R. Castro
 * @param pFoo An instance of the same type as this object.
 * @return A boolean value describing the inverse of whether the objects are equivalent or not.
 */
bool Color::operator!=(const Color &pColor) const {
	return !(*this == pColor);
}

/*
HSV 0..255
*/
void HPRGB::goToHSB(uint8_t hue, uint8_t saturation, uint8_t value)
{
  uint8_t r, g, b;
  HSBtoRGB(hue, saturation, value, &r, &g, &b);
  goToRGB(r, g, b);
}

void HPRGB::HSBtoRGB(uint8_t h, uint8_t s, uint8_t v, uint8_t* r, uint8_t* g, uint8_t* b)
{

        if ( s == 0 )
        {
                *b = *g = *r = v;
        }
        else
        {       
                
                uint8_t i = (h*6)/256;
                uint16_t f = (h*6) % 256;

                uint16_t p = (v * (255 - s)) / 256;
                uint16_t q = (v * (255 - (s * f)/256)) / 256;
                uint16_t t = (v * (255 - (s * (255 - f))/256)) / 256;

                if      ( i == 0 ) { *r = v ; *g = t ; *b = p; } // 0   deg (r)   to 60  deg (r+g)
                else if ( i == 1 ) { *r = q ; *g = v ; *b = p; } // 60  deg (r+g) to 120 deg (g)
                else if ( i == 2 ) { *r = p ; *g = v ; *b = t; } // 120 deg (g)   to 180 deg (g+b)
                else if ( i == 3 ) { *r = p ; *g = q ; *b = v; } // 180 deg (g+b) to 240 deg (b)
                else if ( i == 4 ) { *r = t ; *g = p ; *b = v; } // 240 deg (b)   to 300 deg (b+r)
                else               { *r = v ; *g = p ; *b = q; } // 300 deg (b+r) to 0   deg (r)
        }

}

/*
HSV 0-768
*/
void HPRGB::goToHSB16(uint16_t hue, uint8_t saturation, uint8_t value)
{
	uint8_t r, g, b;
	HSBtoRGB16(hue, saturation, value, &r, &g, &b);
	goToRGB(r, g, b);
}

void HPRGB::HSBtoRGB16(uint16_t index, uint8_t sat, uint8_t bright, uint8_t* r, uint8_t* g, uint8_t *b  )
{
	uint16_t r_temp, g_temp, b_temp;
	uint8_t index_mod;
	uint8_t inverse_sat = (sat ^ 255);
	
	index = index % 768;
	index_mod = index % 256;
	
	if (index < 256)
	{
		r_temp = index_mod ^ 255;
		g_temp = index_mod;
		b_temp = 0;
	}
	
	else if (index < 512)
	{
		r_temp = 0;
		g_temp = index_mod ^ 255;
		b_temp = index_mod;
	}
	
	else if ( index < 768)
	{
		r_temp = index_mod;
		g_temp = 0;
		b_temp = index_mod ^ 255;
	}
	
	else
	{
		r_temp = 0;
		g_temp = 0;
		b_temp = 0;
	}
	
	r_temp = ((r_temp * sat) / 255) + inverse_sat;
	g_temp = ((g_temp * sat) / 255) + inverse_sat;
	b_temp = ((b_temp * sat) / 255) + inverse_sat;
	
	r_temp = (r_temp * bright) / 255;
	g_temp = (g_temp * bright) / 255;
	b_temp = (b_temp * bright) / 255;
	
	*r = (uint8_t)r_temp;
	*g = (uint8_t)g_temp;
	*b = (uint8_t)b_temp;
}

// Convert HSL (Hue, Saturation, Lightness) to RGB (Red, Green, Blue)
//
//   hue:        0 to 359 - position on the color wheel, 0=red, 60=orange,
//                            120=yellow, 180=green, 240=blue, 300=violet
//
//   saturation: 0 to 100 - how bright or dull the color, 100=full, 0=gray
//
//   lightness:  0 to 100 - how light the color is, 100=white, 50=color, 0=black
//
int makeColor(unsigned int hue, unsigned int saturation, unsigned int lightness)
{
        unsigned int red, green, blue;
        unsigned int var1, var2;

        if (hue > 359) hue = hue % 360;
        if (saturation > 100) saturation = 100;
        if (lightness > 100) lightness = 100;

        // algorithm from: http://www.easyrgb.com/index.php?X=MATH&H=19#text19
        if (saturation == 0) {
                red = green = blue = lightness * 255 / 100;
        } else {
                if (lightness < 50) {
                        var2 = lightness * (100 + saturation);
                } else {
                        var2 = ((lightness + saturation) * 100) - (saturation * lightness);
                }
                var1 = lightness * 200 - var2;
                red = h2rgb(var1, var2, (hue < 240) ? hue + 120 : hue - 240) * 255 / 600000;
                green = h2rgb(var1, var2, hue) * 255 / 600000;
                blue = h2rgb(var1, var2, (hue >= 120) ? hue - 120 : hue + 240) * 255 / 600000;
        }
        return (red << 16) | (green << 8) | blue;
}

unsigned int h2rgb(unsigned int v1, unsigned int v2, unsigned int hue)
{
        if (hue < 60) return v1 * 60 + (v2 - v1) * hue;
        if (hue < 180) return v2 * 60;
        if (hue < 240) return v1 * 60 + (v2 - v1) * (240 - hue);
        return v1 * 60;
}

            // set pixel
            b = sdbuffer[buffidx++];
            g = sdbuffer[buffidx++];
            r = sdbuffer[buffidx++];

            povbuffer[povidx++] = Color(b,g,r);//octo colour
          }
        for(int i=0;i<ledsPerStrip;i++){
   leds.setPixel(i, povbuffer[i]); }
        leds.show();