Бинаризация, фильтрация, выделение контуров объектов с видео и потока с камеры - Страница 4

ramshteks · 01.05.2012, 03:01

Код AS3:

var pixelValuepm1:uint = getUint(v,w,i+1,j-1); //св
					var pixelValuep1:uint = getUint(v,w,i+1,j); //в
					var pixelValuepp1:uint = getUint(v,w,i+1,j+1); //юв
 
					var pixelValue1m:uint = getUint(v,w,i,j-1); //с
					var pixelValue1:uint = getUint(v,w,i,j); //ц
					var pixelValue1p:uint = getUint(v,w,i,j+1); //ю
 
					var pixelValuemm1:uint = getUint(v,w,i-1,j-1); //сз
					var pixelValuem1:uint = getUint(v,w,i-1,j); //з
					var pixelValuemp1:uint = getUint(v,w,i-1,j+1); //юз

Вот эта операция задается с помощью списка сдвигов. И решается в цикле. Ну это так на заметку=)

sephira · 01.05.2012, 04:21

Сдвиги по вектору? А код можете написать? Приблизительно представляю, но там сложность с тем, что не подряд расположены элементы в векторе.

alatar · 01.05.2012, 14:34

Цитата:

Сообщение от sephira

При сегментации 128 уровней уже явные тормоза.

Код AS3:

private function enterFrameHandler(event:Event):void
{
	bd.draw(video);
	var v:Vector.<uint> = bd.getVector(rect);
	segmetize3(v, palette ||= getPalette(128));
	bd.setVector(rect, v);
}
 
private function getPalette(cnt:int):Vector.<uint>
{
	var v:Vector.<uint> = new Vector.<uint>();
	var k:int = 256 / cnt;
 
	for (var i:int = 0; i < cnt; i++)
	{
		for (var j:int = 0; j < k; j++)
		{
			var color:uint = i / cnt * 256;
			v.push(color * 256 * 256 + color * 256 + color);
		}
	}
	return v;
}
 
private function segmetize3(pixels:Vector.<uint>, palette:Vector.<uint>):void
{
	var n:int = pixels.length;
 
	for (var i:int = 0; i < n; i++)
	{
		var red:uint = pixels[i] >> 16 & 0xFF;
		pixels[i] = palette[red];
	}
}

Добавлено через 10 минут
Или так:

Код AS3:

private var palette:Array = getPalette(128);
private var nullPalette:Array = getNullPalette();
private var p:Point = new Point();
 
private function enterFrameHandler(event:Event):void
{
	bd.draw(video);
	bd.paletteMap(bd, rect, p, palette, nullPalette, nullPalette, nullPalette);
}
 
private function getPalette(cnt:int):Array
{
	var v:Array = new Array;
	var k:int = 256 / cnt;
 
	for (var i:int = 0; i < cnt; i++)
	{
		for (var j:int = 0; j < k; j++)
		{
			var color:uint = i / cnt * 256;
			v.push(color * 256 * 256 + color * 256 + color);
		}
	}
	return v;
}
 
private function getNullPalette():Array
{
	var arr:Array = [];
 
	for (var i:int = 0; i < 256; i++)
	{
		arr[i] = 0;
	}
	return arr;
}

sephira · 01.05.2012, 16:23

Цитата:

Сообщение от ramshteks

Вот эта операция задается с помощью списка сдвигов. И решается в цикле. Ну это так на заметку=)

Или циклы типа

Код AS3:

for(var a:uint = -1; a<2;a++)

?

Добавлено через 33 секунды
alatar, спасибо, попробую)

ramshteks · 01.05.2012, 20:48

делаете массив сдвигов вроде:

Код AS1/AS2:

var shifts:Array = new Array();
 
			shifts.push(new Coordinate(1, -1));
			shifts.push(new Coordinate(1, 0));
			shifts.push(new Coordinate(1, 1));
 
			shifts.push(new Coordinate(0, 1));
			shifts.push(new Coordinate(-1, 1));
 
			shifts.push(new Coordinate(-1, 0));
			shifts.push(new Coordinate( -1, -1));
			shifts.push(new Coordinate(0, -1));

потом вы можете сгенерировать массив точек относительно начальной с помощью shifts

Код AS3:

var result:Array = new Array();
var start:Coordinate = new Coordinate(x, y);//начальная координата
 
for(var i:int = 0, len:int = shifts.length; i< len; i++)res.push(new Coordinate(start.x+shifts[i].x, start.y + shifts[i]));

За точность кода не отвечаю, но суть думаю ясна. Тот порядок сдвигов, который вы зададите и будет отражен в результирующем массиве. Класс Coordinate это аналог flash.geom.Point. Если в shifts зададите 0,0 получите отсутствие сдвига, то есть "центр" который я у вас там заметил

Добавлено через 1 минуту

Цитата:

Сообщение от sephira

Или циклы типа

Код AS3:

for(var a:uint = -1; a<2;a++)

?

Добавлено через 33 секунды
alatar, спасибо, попробую)

uint не может быть равен -1, это беззнаковый тип

Добавлено через 4 минуты
И вот еще момент. alatar прав. Добейтесь сначала работоспособности. Медленная и работающая программа гораздо лучше, чем быстрая и НЕработающая =)

sephira · 01.05.2012, 22:52

ramshteks, с uint'ом да. Когда работаешь на языках с динамической типизацией, отвыкаешь от слежки за знаковостью чисел.

Код AS3:

package 
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.events.NetStatusEvent;
	import flash.events.SecurityErrorEvent;
	import flash.geom.Rectangle;
	import flash.media.Camera;
	import flash.media.Video;
	import flash.net.NetConnection;
	import flash.net.NetStream;
	import flash.utils.ByteArray;
	import flash.utils.Timer;
 
	public class TestVideo2 extends Sprite 
	{
		private var videoURL:String = "Deeper112.flv";
		private var connection:NetConnection;
		private var stream:NetStream;
		private var video:Video = new Video(480, 360);
		private var bitmap:Bitmap = new Bitmap();
		private var bd:BitmapData;
		public var myTimer:Timer = new Timer(5000);
		public var newV:Vector.<uint>;
 
		public function TestVideo2():void 
		{
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}
 
		public function getUint (v:Vector.<uint>,width:uint,i:uint,j:uint):uint
		{
			var tmp:uint = i+j*width;
			return v[tmp];
		}
 
		public function setUint (v:Vector.<uint>,i:uint,j:uint,width:uint,value:uint):void
		{
			var tmp:uint = i+j*width;
			v[tmp] = value;
		}
 
		private function init(e:Event = null):void 
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
 
			connection = new NetConnection();
			connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
			connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
			connection.connect(null);
		}
 
		private function netStatusHandler(event:NetStatusEvent):void {
			switch (event.info.code) {
				case "NetConnection.Connect.Success":
					connectStream();
					break;
				case "NetStream.Play.StreamNotFound":
					trace("Stream not found: " + videoURL);
					break;
			}
		}
 
		private function securityErrorHandler(event:SecurityErrorEvent):void {
			trace("securityErrorHandler: " + event);
		}
 
		private function connectStream():void {
			var stream:NetStream = new NetStream(connection);
			var client:Object = new Object();
			client.onMetaData = onMetaData;
			stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
			stream.client = client;
			video.attachNetStream(stream);
			stream.play(videoURL);
			bd = new BitmapData(video.width, video.height, false);
			bitmap.bitmapData = bd;
			bitmap.x = video.width;
			addChild(video);
			addChild(bitmap);
		}
 
		private function connectCamera():void {
			var camera:Camera = Camera.getCamera();
			video.attachCamera(camera);
			bd = new BitmapData(video.width, video.height, false);
			bitmap.bitmapData = bd;
			bitmap.x = video.width;
			addChild(video);
			addChild(bitmap);
			myTimer.addEventListener("timer", enterFrameHandler);
			myTimer.start();
		}
 
		private function onMetaData(info:Object):void {
			trace("metadata: duration=" + info.duration + " width=" + info.width + " height=" + info.height + " framerate=" + info.framerate);
			myTimer.addEventListener("timer", enterFrameHandler);
			myTimer.start();
		}
 
		private function enterFrameHandler(event:Event):void
		{
			bd.draw(video);
			var v:Vector.<uint> = new Vector.<uint>();
			var rct:Rectangle = new Rectangle(0,0,bd.width,bd.height);
			v = bd.getVector(rct);
			if(!newV) newV = bd.getVector(rct);
			computeData(v,bd.width,bd.height);
			//prevV = bd.getVector(rct);
			bd.setVector(rct,newV);
		}
 
		public function computeData(v:Vector.<uint>,w:uint,h:uint):void
		{
			//binarization(v,w,h);
			//mediumRGB(v,w,h);
			//medianFilter(v,w,h);
 
			uniformNoise(v,w,h);
			medianFilter(newV,w,h);
 
			//sobel(v,w,h);
		}
 
		public function binarization(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=0;i<w;i++)
			{
				for (var j:uint=0;j<h;j++)
				{
					var pixelValue:uint = getUint(v,w,i,j);
					var red:uint = pixelValue >> 16 & 0xFF;
					var green:uint = pixelValue >> 8 & 0xFF;
					var blue:uint = pixelValue & 0xFF;
 
					if (red > 127) var color:uint = 0xFFFFFF; else color = 0;
					var tmp:uint = color;
					setUint(newV,i,j,w,tmp);
				}
			}
		}
 
		private function segmentation(v:Vector.<uint>,w:uint,h:uint,cnt:uint):void
		{
			var n:int = v.length;
			var levels:Array = new Array();
			for(var k:uint=0; k < cnt; k++)
			{
				levels[k] = k/cnt*256;
			}
 
			for (var i:int = 0; i < n; i++)
			{
				var red:uint = v[i] >> 16 & 0xFF;
				for(k = 0; k < cnt; k++)
				{
					if(red>=levels[k] && red<levels[k+1])
					{
						var color:uint = levels[k];
					}
				}
 
				var tmp:uint = color * 256 * 256 + color * 256 + color;
				newV[i] = tmp;
			}
		}
 
		public function medianFilter(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=0;i<w-2;i++)
			{
				for (var j:uint=0;j<h-2;j++)
				{
					var tmp:Array = new Array();
					for(var a:uint=0;a<3;a++)
					{
						for(var b:uint=0;b<3;b++)
						{
							tmp[a*3+b] = getUint(v,w,i+a,j+b);
						}
					}
					tmp.sort(Array.NUMERIC);
					setUint(newV,i+1,j+1,w,tmp[5]);
					tmp = null;
				}
			}
		}
 
		public function uniformNoise(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=0;i<w;i++)
			{
				for (var j:uint=0;j<h;j++)
				{
					var pixelValue:uint = getUint(v,w,i,j);
					var red:uint = pixelValue >> 16 & 0xFF;
					var green:uint = pixelValue >> 8 & 0xFF;
					var blue:uint = pixelValue & 0xFF;
 
					red = Math.min(255,red+(Math.random()-0.5)*10);
					green = Math.min(255,green+(Math.random()-0.5)*10);
					blue = Math.min(255,blue+(Math.random()-0.5)*10);
 
					var tmp:uint = red*256*256+green*256+blue;
					setUint(newV,i,j,w,tmp);
				}
			}
		}
 
		public function maxRGB(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=0;i<w;i++)
			{
				for (var j:uint=0;j<h;j++)
				{
					var pixelValue:uint = getUint(v,w,i,j);
					var red:uint = pixelValue >> 16 & 0xFF;
					var green:uint = pixelValue >> 8 & 0xFF;
					var blue:uint = pixelValue & 0xFF;
 
					if(red>=green)
					{
						if(red>=blue)
						{
							setUint(v,i,j,w,red*256*256);
						}
						else
						{
							setUint(v,i,j,w,blue);
						}
					}
					else
					{
						if(green>=blue)
						{
							setUint(v,i,j,w,green*256);
						}
						else
						{
							setUint(newV,i,j,w,blue);
						}
					}
				}
			}
		}
 
		public function mediumRGB(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=0;i<w;i++)
			{
				for (var j:uint=0;j<h;j++)
				{
					var pixelValue:uint = getUint(v,w,i,j);
					var red:uint = pixelValue >> 16 & 0xFF;
					var green:uint = pixelValue >> 8 & 0xFF;
					var blue:uint = pixelValue & 0xFF;
 
					var color:uint = (red+green+blue)/3;
					var tmp:uint = color*256*256+color*256+color;
					setUint(newV,i,j,w,tmp);
 
				}
			}
		}
 
		public function toBlackWhite(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=0;i<w;i++)
			{
				for (var j:uint=0;j<h;j++)
				{
					var pixelValue:uint = getUint(v,w,i,j);
					var red:uint = pixelValue >> 16 & 0xFF;
					var green:uint = pixelValue >> 8 & 0xFF;
					var blue:uint = pixelValue & 0xFF;
 
					var color:uint = red*0.299+green*0.587+blue*0.114;
					var tmp:uint = color*256*256+color*256+color;
					setUint(newV,i,j,w,tmp);
 
				}
			}
		}
 
		public function normalize(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=0;i<w;i++)
			{
				for (var j:uint=0;j<h;j++)
				{
					var pixelValue:uint = getUint(v,w,i,j);
					var red:uint = pixelValue >> 16 & 0xFF;
					var green:uint = pixelValue >> 8 & 0xFF;
					var blue:uint = pixelValue & 0xFF;
 
					var sum:uint = red+green+blue;
 
					red = red/sum;
					green = green/sum;
					blue = blue/sum;
 
					var tmp:uint = red*256*256+green*256+blue;
					setUint(newV,i,j,w,tmp);
 
				}
			}
		}

sephira · 01.05.2012, 22:53

Код AS3:

		public function sobel(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=1;i<w-1;i++)
			{
				for (var j:uint=1;j<h-1;j++)
				{
					var pixelValuepm1:uint = getUint(v,w,i+1,j-1)& 0xFF; //св
					var pixelValuep1:uint = getUint(v,w,i+1,j)& 0xFF; //в
					var pixelValuepp1:uint = getUint(v,w,i+1,j+1)& 0xFF; //юв
 
					var pixelValue1m:uint = getUint(v,w,i,j-1)& 0xFF; //с
					var pixelValue1:uint = getUint(v,w,i,j)& 0xFF; //ц
					var pixelValue1p:uint = getUint(v,w,i,j+1)& 0xFF; //ю
 
					var pixelValuemm1:uint = getUint(v,w,i-1,j-1)& 0xFF; //сз
					var pixelValuem1:uint = getUint(v,w,i-1,j)& 0xFF; //з
					var pixelValuemp1:uint = getUint(v,w,i-1,j+1)& 0xFF; //юз
 
					var a:int = pixelValuepm1 - pixelValuemm1;
					var b:int = 2*pixelValuep1 - 2*pixelValuem1;
					var c:int = pixelValuepp1 - pixelValuemp1;
 
					var dfdx:int = (a+b+c);
 
					var d:int = -pixelValuemp1 + pixelValuemm1;
					var e:int = -2*pixelValue1p + 2*pixelValue1m;
					var f:int = -pixelValuepp1 + pixelValuepm1;
 
					var dfdy:int = (d+e+f);
 
					var ma:int = Math.abs(dfdx)+Math.abs(dfdy);
					var tmp:uint = (ma>50) ? 0xFFFFFF : 0;
					//tmp = tmp*256*256+tmp*256+tmp;
					setUint(newV,i,j,w,tmp);
 
				}
			}
		}
 
		public function roberts(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=0;i<w-1;i++)
			{
				for (var j:uint=0;j<h-1;j++)
				{
					var pixelValuep1:uint = getUint(v,w,i+1,j)& 0xFF; //в
					var pixelValuepp1:uint = getUint(v,w,i+1,j+1)& 0xFF; //юв
 
					var pixelValue1:uint = getUint(v,w,i,j)& 0xFF; //ц
					var pixelValue1p:uint = getUint(v,w,i,j+1)& 0xFF; //ю
 
					var dfdx:int = pixelValue1 - pixelValuepp1;
 
					var dfdy:int = pixelValuep1 - pixelValue1p;
 
					var ma:int = Math.abs(dfdx)+Math.abs(dfdy);
					var tmp:uint = (ma>35) ? 0xFFFFFF : 0;
					//tmp = tmp*256*256+tmp*256+tmp;
					setUint(newV,i,j,w,tmp);
 
				}
			}
		}
 
		public function differential(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=0;i<w-1;i++)
			{
				for (var j:uint=0;j<h-1;j++)
				{
					var pixelValuep1:uint = getUint(v,w,i+1,j)& 0xFF; //в
					var pixelValuepp1:uint = getUint(v,w,i+1,j+1)& 0xFF; //юв
 
					var pixelValue1:uint = getUint(v,w,i,j)& 0xFF; //ц
					var pixelValue1p:uint = getUint(v,w,i,j+1)& 0xFF; //ю
 
					var a:int = pixelValue1 + pixelValuep1;
					var b:int = pixelValue1p + pixelValuepp1;
 
					var dfdx:int = (a-b);
 
					var c:int = pixelValuep1 + pixelValuepp1;
					var d:int = pixelValue1 + pixelValue1p;
 
					var dfdy:int = (c-d);
 
					var ma:int = Math.abs(dfdx)+Math.abs(dfdy);
					var tmp:uint = (ma>50) ? 0xFFFFFF : 0;
					//tmp = tmp*256*256+tmp*256+tmp;
					setUint(newV,i,j,w,tmp);
 
				}
			}
		}
 
		public function timecontoure(v:Vector.<uint>,w:uint,h:uint):void
		{
			for (var i:uint=1;i<w-1;i++)
			{
				for (var j:uint=1;j<h-1;j++)
				{
					//var pixelValue:uint = getUint(v,w,i,j);
					//var prevPixelValue:uint = getUint(prevV,w,i,j);
					//var ma:Number = pixelValue - prevPixelValue;
					//var tmp:uint = ma/0xFFFFFFFF*256;
					//tmp = tmp*256*256+tmp*256+tmp;
					//setUint(v,i,j,w,tmp);
 
				}
			}
		}
 
	}
}

Пока есть вот это. Не совершенное, но рабочее.

Добавлено через 6 минут
Кстати.

Цитата:

Код AS3:

start.y + shifts[i]

Верно:

Код AS3:

start.y + shifts[i].y

Это к uint'у.

Добавлено через 8 минут
За реализацию спасибо.)

ramshteks · 01.05.2012, 23:47

конечно ".y", писал по памяти, хорошо что увидели )

Добавлено через 44 минуты
Вот ваша функция во много раз быстрее теперь

Код AS3:

public function binarization(v:Vector.<uint>,w:uint,h:uint):void
		{
			var i:int, len:int;
			for (i = 0, len = v.length; i < len; i++) {
				newV[i] = ((v[i] >> 16) & 0xFF) > 127?0xFFFFFF:0;
			}
		}

Совет вам, по оптимизации в будущем, постарайтесь избегать различных вызовов в и без того "дорогих" циклах. На моем ящике старая binarization считалась около 500мс, теперь около 30. Но это все ценой читаемости. Всегда приходится чем то жертвовать =)

sephira · 02.05.2012, 02:20

Даже обращение к свойству

Код AS3:

v.length

посчитали драгоценным) Тогда ясно)

wvxvw · 02.05.2012, 02:26

А к чему такие военные хитрости? (v[i] & 0x800000) ? 0хFFFFFF : 0 эквивалентно же ((v[i] >> 16) & 0xFF) > 127 ? 0xFFFFFF : 0;