Первая страница
Наша команда
Контакты
О нас

    Головна сторінка



Пояснювальна записка до магістерської кваліфікаційної роботи магістра

Пояснювальна записка до магістерської кваліфікаційної роботи магістра




Сторінка8/9
Дата конвертації13.03.2017
Розмір1.59 Mb.
ТипПояснювальна записка
1   2   3   4   5   6   7   8   9

ТЕХНІЧНЕ ЗАВДАННЯ

на виконання магістерської кваліфікаційної роботи

Відстежування переміщення обличчя людини на основі сегментації зображень

08-23.МКР.013.00.000 ТЗ


Науковий керівник: д.т.н., професор

_________ Мартинюк Т. Б.

(підпис)

Магістрант групи 1КІ-14м

_________ Тохтунов А. О.

(підпис)

Вінниця 2015 р.


1. Підстава для виконання магістерської кваліфікаційної роботи (МКР)

а) Актуальність даного дослідження визначається необхідністю вирішення основних проблем існуючих засобів знаходження та відстеження переміщення обличчя людини. Особливо актуальним дане дослідження є у зв’язку з тенденціями до впровадження таких засобів у різноманітних додатках по управлінню процесами, такі як керування пристроєм, керування об’єктами, виконання різноманітних дій відносно положення голови.

б) Наказ про затвердження теми магістерської кваліфікаційної роботи.

2. Мета і призначення МКР

а) Мета магістерської роботи полягає у підвищенні ефективності засобів знаходження та відстеження переміщення обличчя людини. Підвищення ефективності способу пошуку та відстеження переміщення обличчя людини заключається в більш точній перевірці відповідності знайдених об’єктів на зображенні обличчю людини.

б)Призначення розробки – виконання магістерської кваліфікаційної роботи.

3. Вихідні дані для виконання МКР

Виконати розробку програмного забезпечення для знаходження та відстеження переміщення обличчя людини та провести його тестування. Схеми алгоритмів для знаходження та відстеження переміщення обличчя людини та лістинги програми представити в додатках до роботи.



4. Вимоги до виконання МКР

  • запропонувати нові підходи для реалізації способу пошуку та відстеження переміщення обличчя людини;

  • розробити алгоритм для знаходження та відстеження переміщення обличчя людини;

  • розробити алгоритм сегментації зображень для пошуку обличчя людини з метою відстеження його переміщення.

Для нормальної роботи програми, необхідно комп’ютер з такою мінімальною конфігурацією:

  • наявність кольорового монітору SVGA, з діагоналлю 15”, роздільна здатність не менше 800х600 точок, при частоті 85 hz оновлення екрану та глибині кольору 32 bit;

  • процесор рівня IntelCore2 з частотою 2,66 Ghz;

  • розмір оперативної пам’яті (RAM) не менше 1012 Mb;

  • розмір жорсткого диску (HDD) 20 Gb;

  • операційна система Microsoft Windows 9x.


5. Етапи МКР та очікувані результати

етапу

Назва етапу


Термін виконання

Очікувані результати

початок

кінець

1

Аналіз завдання. Вступ

01.07.15

10.07.15

Вступ

2

Аналіз літературних джерел по виділенню та відстеженню переміщення обличчя людини

11.07.15

30.07.15

розділ 1

3

Розробка технічного завдання

23.07.15

27.07.15

Технічне завдання

4

Розробка способу та алгоритмів виділення та відстеження переміщення обличчя людини

01.08.15

30.08.15

Розділ 2, розробка способу

5

Розробка програми, моделей, алгоритмів

1.09.15

30.09.15

Розділ 3, розробка програми

6

Практична реалізація, моделювання, результати

01.10.15

15.10.15

Розділ 3, моделювання

7

Розробка економічної частини

16.10.15

30.10.15

Розділ 4

9

Оформлення пояснювальної записки

1.11.15

16.11.15

ПЗ, презентація


7. Матеріали, що подаються до захисту МКР

Пояснювальна записка МКР, графічні і ілюстративні матеріали, протокол попереднього захисту МКР на кафедрі, відзив наукового керівника, відзив опонента, протоколи складання державних екзаменів, анотації до МКР українською та іноземною мовами.



8. Порядок контролю виконання та захисту МКР

Виконання етапів розрахункової та графічної документації МКР контролюється науковим керівником згідно зі встановленими термінами. Захист МКР відбувається на засіданні Державної екзаменаційної комісії, затвердженою наказом ректора.



9. Вимоги до оформлення МКР

Вимоги викладені в «Положенні про порядок підготовки магістрів у Вінницькому національному технічному університеті» з урахуванням змін, що подані у бюлетені ВАК України № 9-10, 2011р.



10. Вимоги щодо технічного захисту інформації в МКР з обмеженим

доступом

Відсутні.


Технічне завдання до виконання отримав ____________ Тохтунов А. О.

Додаток Б

Лістинг програми
sing System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.Windows.Threading;

using Emgu.CV.Structure;

using Emgu.CV;

using System.Runtime.InteropServices;


namespace Emg

{

public partial class MainWindow : Window



{

public MainWindow()

{

InitializeComponent();



}

private Capture capture;

private HaarCascade haarCascade;

DispatcherTimer timer;


private void Window_Loaded(object sender, RoutedEventArgs e)

{

capture = new Capture();



haarCascade = new HaarCascade(@"haarcascade_frontalface_alt_tree.xml");

timer = new DispatcherTimer();

timer.Tick += new EventHandler(timer_Tick);

timer.Interval = new TimeSpan(0, 0, 0, 0, 0);

timer.Start();

}

void timer_Tick(object sender, EventArgs e)



{

Image currentFrame = capture.QueryFrame();


if (currentFrame != null)

{

Image grayFrame = currentFrame.Convert(); var detectedFaces = grayFrame.DetectHaarCascade(haarCascade)[0];



foreach (var face in detectedFaces)

{

currentFrame.Draw(face.rect, new Bgr(0, double.MaxValue, 0), 3);



if (detectedFaces.Length > 1)

currentFrame.Draw(face.rect, new Bgr(1, 29, 89), 3);


}
image1.Source = ToBitmapSource(currentFrame);
currentFrame.Dispose();

}
}


[DllImport("gdi32")]

private static extern int DeleteObject(IntPtr o);


public static BitmapSource ToBitmapSource(IImage image)

{

using (System.Drawing.Bitmap source = image.Bitmap)



{

IntPtr ptr = source.GetHbitmap();


BitmapSource bs = System.Windows.Interop

.Imaging.CreateBitmapSourceFromHBitmap(

ptr,

IntPtr.Zero,



Int32Rect.Empty,

System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());


DeleteObject(ptr); //release the HBitmap

return bs;

}

}

}



}

public static YCbCrColor FromArgbColori(int color)

const float f = 1f / 255f;

var r = (byte)(color >> 16) * f;

var g = (byte)(color >> 8) * f;

var b = (byte)(color) * f;

var y = 0.299f * r + 0.587f * g + 0.114f * b;

var cb = -0.168736f * r + -0.331264f * g + 0.5f * b;

var cr = 0.5f * r + -0.418688f * g + -0.081312f * b;

return new YCbCrColor(y, cb, cr);


public WriteableBitmap Process(WriteableBitmap snapshot)

{

var p = snapshot.Pixels;



var result = new WriteableBitmap(snapshot.PixelWidth, snapshot.PixelHeight);

var rp = result.Pixels;

for (int i = 0; i < p.Length; i++)

{

var ycbcr = YCbCrColor.FromArgbColori(p[i]);



if (ycbcr.Y >= LowerThreshold.Y && ycbcr.Y <= UpperThreshold.Y

&& ycbcr.Cb >= LowerThreshold.Cb && ycbcr.Cb <= UpperThreshold.Cb

&& ycbcr.Cr >= LowerThreshold.Cr && ycbcr.Cr <= UpperThreshold.Cr)

{

rp[i] = 0xFFFFFF;



}

}

return result;



}

private void segmentation()

{

IplImage saveWork = cvCloneImage(work);



float arg1 = 1;

float arg2 = 1;

int arg3 = 1;

try {


arg1 = Float.parseFloat(otsMField.getText());

arg2 = Float.parseFloat(otsHField.getText());

arg3 = Integer.parseInt(clastField.getText());

} catch (NumberFormatException e1) {

arg1 = 1;

arg2 = 1;

arg3 = 1;

}

multiplerOne = arg1;



multiplerSecond = arg2;
if (work.getBufferedImageType() != 10)

{


tmp = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);

cvCvtColor(work, tmp, CV_RGB2GRAY);

work = cvCloneImage(tmp);



cvSmooth(work, work, CV_MEDIAN, 7, 7, 0, 0);

IplImage smoothImage;


smoothImage = cvCloneImage(work);

IplImage partSecond;


partOne = difHeign();

partSecond = difWidth();

}

imgVertical = partSecond;



imgHorizontal = partOne;

IplImage wKontur = getWKontur();

IplImage hKontur = getHKontur();
IplImage kontur = mixInOne(wKontur, hKontur);
public void clast() {

int min = getMin();

int max = getMax();

int clast_index = 0;


for (int i = 0; i < claster_count; i++)

{


centroids.add(new ClastCentr((rand.nextInt(max - min - 1) + min)

+ rand.nextFloat(), clast_index++));

}

boolean isCheng = true;


while (isCheng) {

isCheng = false;

iteration();

for (ClastCentr i : centroids)

{

if (i.isChengPosition)



isCheng = true;

for (ClastCentr i : centroids)

{

i.calcPosition();



}

min = 257;

int index = 0;

for (ClastPoint i : points)

{

min = 257;



for (int k = 0; k < claster_count; k++)

{

if (k == i.claster.number)



continue;

if (Math.abs(i.position - centroids.get(k).position) < min)

{

min = (int) Math.abs(i.position - centroids.get(k).position);



index = k;

}

int realDistans = (int) Math.abs(i.position - i.claster.position);



if ((realDistans / min) > 0.95)

{

i.alternativ_claster = centroids.get(index);



}

for (ClastPoint i : points)

{

if (i.alternativ_claster != null)



{

int crossingAlternativ = getNumberOfCrossing(i.X, i.Y,

i.alternativ_claster.X, i.alternativ_claster.Y);

int crossingMain = getNumberOfCrossing(i.X, i.Y, i.claster.X,

i.claster.Y);

if (crossingMain == crossingAlternativ)

{

}

if (crossingAlternativ < crossingMain)



{

i.claster = i.alternativ_claster;


public void calcColor() {

int R = 0;

int B = 0;

int G = 0;

int[] tmp = new int[3];

for (ClastPoint i : points) {

tmp = i.color;

R += tmp[0];

G += tmp[1];

B += tmp[2];

}

if (points.size() > 0)



{

R = R / points.size();

G = G / points.size();

B = B / points.size();

}

color = new int[] { R, G, B };



}
public void calcPosition()

{

int X = 0;



int Y = 0;

for (ClastPoint i : points)

{

X += i.X;



Y += i.Y;

}

if (points.size() > 0)



{

this.X = X / points.size();

this.Y = Y / points.size();

}
Clastering clast = new Clastering(smoothImage, arg3, src, kontur);

clast.clast();

hough2.showImage(kontur.getBufferedImage());

showBorder(clast.getRezColor(), kontur);

work = cvCloneImage(saveWork);


{    [Serializable]
    public class Image : CvArray, IImage, IDisposable, ICloneable, IEquatable> where TColor : struct, IColor where TDepth : new()
    {
        private TDepth[,,] _array;

        private static readonly int _numberOfChannels;

        public TDepth[,,] Data
        {
            get
            {
                return this._array;
            }
            set
            {
                this.AllocateData(value.GetLength(0), value.GetLength(1), this.NumberOfChannels);
                int length = value.GetLength(0);
                int num = value.GetLength(1) * value.GetLength(2);
                int num2 = this._array.GetLength(1) * this._array.GetLength(2);
                for (int i = 0; i < length; i++)
                {
                    Array.Copy(value, i * num, this._array, i * num2, num);
                }
            }
        }        public MIplImage MIplImage
        {
            get
            {
                return (MIplImage)Marshal.PtrToStructure(base.Ptr, typeof(MIplImage));
            }
        }

        public Rectangle ROI


        {
            get
            {
                return CvInvoke.cvGetImageROI(base.Ptr);
            }
            set
            {
                if (value.Equals(Rectangle.Empty))
                {
                    CvInvoke.cvResetImageROI(base.Ptr);
                    return;
                }
                CvInvoke.cvSetImageROI(base.Ptr, value);
            }
        }

        public override int NumberOfChannels


        {
            get
            {
                return Image._numberOfChannels;
            }
        }        public override Array ManagedArray
        {
            get
            {
                return this._array;
            }
            set
            {
                TDepth[,,] array = value as TDepth[,,];
                if (array == null)
                {
                    throw new InvalidCastException(string.Format("Cannot convert ManagedArray to type of {0}[,,].", typeof(TDepth).ToString()));
                }
                this.Data = array;
            }
        }

        public static IPL_DEPTH CvDepth


        {
            get
            {
                Type typeFromHandle = typeof(TDepth);
                if (typeFromHandle == typeof(float))
                {
                    return IPL_DEPTH.IPL_DEPTH_32F;
                }
                if (typeFromHandle == typeof(byte))
                {
                    return IPL_DEPTH.IPL_DEPTH_8U;
                }
                if (typeFromHandle == typeof(double))
                {
                    return IPL_DEPTH.IPL_DEPTH_64F;
                }
                if (typeFromHandle == typeof(sbyte))
                {
                    return (IPL_DEPTH)2147483656u;
                }
                if (typeFromHandle == typeof(ushort))
                {
                    return IPL_DEPTH.IPL_DEPTH_16U;
                }
                if (typeFromHandle == typeof(short))
                {
                    return (IPL_DEPTH)2147483664u;
                }
                if (typeFromHandle == typeof(int))
                {
                    return (IPL_DEPTH)2147483680u;
                }
                throw new NotImplementedException(StringTable.UnsupportedImageDepth);
            }
        }

        public bool IsROISet


        {
            get
            {
                return Marshal.ReadIntPtr(base.Ptr, ImageConstants.RoiOffset) != IntPtr.Zero;
            }
        }

        public Image this[int channel]


        {
            get
            {
                Image image = new Image(base.Size);
                int coi = CvInvoke.cvGetImageCOI(base.Ptr);
                CvInvoke.cvSetImageCOI(base.Ptr, channel + 1);
                CvInvoke.cvCopy(base.Ptr, image.Ptr, IntPtr.Zero);
                CvInvoke.cvSetImageCOI(base.Ptr, coi);
                return image;
            }
            set
            {
                IntPtr[] array = new IntPtr[4];
                array[channel] = value.Ptr;
                CvInvoke.cvCvtPlaneToPix(array[0], array[1], array[2], array[3], base.Ptr);
            }
        }

        public TColor this[int row, int column]


        {
            get
            {
                TColor result = default(TColor);
                result.MCvScalar = CvInvoke.cvGet2D(base.Ptr, row, column);
                return result;
            }
            set
            {
                CvInvoke.cvSet2D(base.Ptr, row, column, value.MCvScalar);
            }
        }

        public TColor this[Point location]


        {
            get
            {
                return this[location.Y, location.X];
            }
            set
            {
                this[location.Y, location.X] = value;
            }
        }

        public Bitmap Bitmap


        {
            get
            {
                IntPtr scan;
                int stride;
                Size size;
                CvInvoke.cvGetRawData(base.Ptr, out scan, out stride, out size);
                if (this is Image)
                {
                    return new Bitmap(size.Width, size.Height, stride, PixelFormat.Format8bppIndexed, scan)
                    {
                        Palette = CvToolbox.GrayscalePalette
                    };
                }
                if (Platform.OperationSystem == OS.Windows && Platform.Runtime == Runtime.DotNet && this is Image)
                {
                    return new Bitmap(size.Width, size.Height, stride, PixelFormat.Format24bppRgb, scan);
                }
                if (this is Image)
                {
                    return new Bitmap(size.Width, size.Height, stride, PixelFormat.Format32bppArgb, scan);
                }
                return this.ToBitmap();
            }
            set
            {
                if (base.Ptr == IntPtr.Zero || !base.Size.Equals(value.Size))
                {
                    this.AllocateData(value.Height, value.Width, this.NumberOfChannels);
                }
                PixelFormat pixelFormat = value.PixelFormat;
                if (pixelFormat <= PixelFormat.Format32bppRgb)
                {
                    if (pixelFormat == PixelFormat.Format24bppRgb)
                    {
                        goto IL_2FF;
                    }
                    if (pixelFormat != PixelFormat.Format32bppRgb)
                    {
                        goto IL_44B;
                    }
                    if (this is Image)
                    {
                        BitmapData bitmapData = value.LockBits(new Rectangle(Point.Empty, value.Size), ImageLockMode.ReadOnly, value.PixelFormat);
                        using (Image image = new Image(value.Width, value.Height, bitmapData.Stride, bitmapData.Scan0))
                        {
                            for (int i = 0; i < 3; i++)
                            {
                                CvInvoke.cvSetImageCOI(base.Ptr, i + 1);
                                CvInvoke.cvSetImageCOI(image, i + 1);
                                CvInvoke.cvCopy(image, base.Ptr, IntPtr.Zero);
                            }
                            CvInvoke.cvSetImageCOI(base.Ptr, 0);
                        }
                        value.UnlockBits(bitmapData);
                        return;
                    }
                    using (Image image2 = new Image(value))
                    {
                        this.ConvertFrom(image2);
                        return;
                    }
                }
                else
                {
                    if (pixelFormat == PixelFormat.Format1bppIndexed)
                    {
                        goto IL_330;
                    }
                    if (pixelFormat == PixelFormat.Format8bppIndexed)
                    {
                        goto IL_193;
                    }
                    if (pixelFormat != PixelFormat.Format32bppArgb)
                    {
                        goto IL_44B;
                    }
                }
                if (this is Image)
                {
                    this.CopyFromBitmap(value);
                    return;
                }
                using (Image image3 = new Image(value))
                {
                    this.ConvertFrom(image3);
                    return;
                }
                IL_193:
                if (this is Image)
                {
                    using (Image image4 = new Image(value.Size))
                    {
                        image4.CopyFromBitmap(value);
                        Matrix matrix;
                        Matrix matrix2;
                        Matrix matrix3;
                        Matrix matrix4;
                        CvToolbox.ColorPaletteToLookupTable(value.Palette, out matrix, out matrix2, out matrix3, out matrix4);
                        using (Image image5 = image4.CopyBlank())
                        {
                            using (Image image6 = image4.CopyBlank())
                            {
                                using (Image image7 = image4.CopyBlank())
                                {
                                    using (Image image8 = image4.CopyBlank())
                                    {
                                        CvInvoke.cvLUT(image4.Ptr, image5.Ptr, matrix.Ptr);
                                        CvInvoke.cvLUT(image4.Ptr, image6.Ptr, matrix2.Ptr);
                                        CvInvoke.cvLUT(image4.Ptr, image7.Ptr, matrix3.Ptr);
                                        CvInvoke.cvLUT(image4.Ptr, image8.Ptr, matrix4.Ptr);
                                        CvInvoke.cvMerge(image5.Ptr, image6.Ptr, image7.Ptr, image8.Ptr, base.Ptr);
                                    }
                                }
                            }
                        }
                        matrix.Dispose();
                        matrix2.Dispose();
                        matrix3.Dispose();
                        matrix4.Dispose();
                        return;
                    }
                }
                using (Image image9 = new Image(value))
                {
                    this.ConvertFrom(image9);
                    return;
                }
                IL_2FF:
                if (this is Image)
                {
                    this.CopyFromBitmap(value);
                    return;
                }
                using (Image image10 = new Image(value))
                {
                    this.ConvertFrom(image10);
                    return;
                }
                IL_330:
                if (this is Image)
                {
                    Size size = value.Size;
                    int height = size.Height;
                    int width = size.Width;
                    BitmapData bitmapData2 = value.LockBits(new Rectangle(Point.Empty, size), ImageLockMode.ReadOnly, value.PixelFormat);
                    int num = width >> 3;
                    int num2 = width & 7;
                    int num3 = 128;
                    long num4 = bitmapData2.Scan0.ToInt64();
                    byte[,,] array = this.Data as byte[,,];
                    byte[] array2 = new byte[num + ((num2 == 0) ? 0 : 1)];
                    int num5 = 0;
                    int j = 0;
                    while (j < height)
                    {
                        Marshal.Copy((IntPtr)num4, array2, 0, array2.Length);
                        int k = 0;
                        while (k < width)
                        {
                            if ((k & 7) == 0)
                            {
                                num5 = (int)array2[k >> 3];
                            }
                            array[j, k, 0] = (((num5 & num3) == 0) ? 0 : 255);
                            k++;
                            num5 <<= 1;
                        }
                        j++;
                        num4 += (long)bitmapData2.Stride;
                    }
                    return;
                }
                using (Image image11 = new Image(value))
                {
                    this.ConvertFrom(image11);
                    return;
                }
                IL_44B:
                using (Image image12 = new Image(value.Size))
                {
                    byte[,,] data = image12.Data;
                    for (int l = 0; l < value.Width; l++)
                    {
                        for (int m = 0; m < value.Height; m++)
                        {
                            Color pixel = value.GetPixel(l, m);
                            data[m, l, 0] = pixel.B;
                            data[m, l, 1] = pixel.G;
                            data[m, l, 2] = pixel.R;
                            data[m, l, 3] = pixel.A;
                        }
                    }
                    this.ConvertFrom(image12);
                }
            }
        }

        protected Image()


        {
        }

        public Image(TDepth[,,] data)


        {
            this.Data = data;
        }

        public Image(int width, int height, int stride, IntPtr scan0)


        {
            this._ptr = CvInvoke.cvCreateImageHeader(new Size(width, height), Image.CvDepth, this.NumberOfChannels);
            MIplImage mIplImage = this.MIplImage;
            mIplImage.imageData = scan0;
            mIplImage.widthStep = stride;
            Marshal.StructureToPtr(mIplImage, this._ptr, false);
        }        public Image(string fileName)
        {
            FileInfo file = new FileInfo(fileName);
            try
            {
                this.LoadImageUsingOpenCV(file);
            }
            catch
            {
                this.LoadFileUsingBitmap(file);
            }
        }        private void LoadFileUsingBitmap(FileInfo file)
        {
            using (Bitmap bitmap = new Bitmap(file.FullName))
            {
                this.Bitmap = bitmap;
            }
        }

        private void LoadImageUsingOpenCV(FileInfo file)


        {
            IntPtr intPtr;
            Size size;
            if (typeof(TColor) == typeof(Gray))
            {
                intPtr = CvInvoke.cvLoadImage(file.FullName, LOAD_IMAGE_TYPE.CV_LOAD_IMAGE_GRAYSCALE);
                size = CvInvoke.cvGetSize(intPtr);
            }
            else
            {
                intPtr = CvInvoke.cvLoadImage(file.FullName, LOAD_IMAGE_TYPE.CV_LOAD_IMAGE_COLOR);
                if (intPtr == IntPtr.Zero)
                {
                    throw new NullReferenceException(string.Format("Unable to load image from file \"{0}\".", file.FullName));
                }
                MIplImage mIplImage = (MIplImage)Marshal.PtrToStructure(intPtr, typeof(MIplImage));
                size = new Size(mIplImage.width, mIplImage.height);
                if (typeof(TColor) != typeof(Bgr))
                {
                    IntPtr intPtr2 = CvInvoke.cvCreateImage(size, mIplImage.depth, 3);
                    CvInvoke.cvCvtColor(intPtr, intPtr2, CvToolbox.GetColorCvtCode(typeof(Bgr), typeof(TColor)));
                    CvInvoke.cvReleaseImage(ref intPtr);
                    intPtr = intPtr2;
                }
            }
            if (typeof(TDepth) != typeof(byte))
            {
                IntPtr intPtr3 = CvInvoke.cvCreateImage(size, Image.CvDepth, this.NumberOfChannels);
                CvInvoke.cvConvertScale(intPtr, intPtr3, 1.0, 0.0);
                CvInvoke.cvReleaseImage(ref intPtr);
                intPtr = intPtr3;
            }
            this.AllocateData(size.Height, size.Width, this.NumberOfChannels);
            CvInvoke.cvCopy(intPtr, base.Ptr, IntPtr.Zero);
            CvInvoke.cvReleaseImage(ref intPtr);
        }        public Image(Bitmap bmp)
        {
            this.Bitmap = bmp;
        }        public Image(int width, int height, TColor value) : this(width, height)
        {
            this.SetValue(value);
        }

        public Image(int width, int height)


        {
            this.AllocateData(height, width, this.NumberOfChannels);
        }

        public Image(Size size) : this(size.Width, size.Height)


        {
        }

        protected override void AllocateData(int rows, int cols, int numberOfChannels)


        {
            this.DisposeObject();
            this._ptr = CvInvoke.cvCreateImageHeader(new Size(cols, rows), Image.CvDepth, numberOfChannels);
            GC.AddMemoryPressure((long)StructSize.MIplImage);
            if (typeof(TDepth) == typeof(byte) && (cols & 3) != 0)
            {
                this._array = new TDepth[rows, (cols & -4) + 4, numberOfChannels];
            }
            else
            {
                this._array = new TDepth[rows, cols, numberOfChannels];
            }
            this._dataHandle = GCHandle.Alloc(this._array, GCHandleType.Pinned);
            CvInvoke.cvSetData(this._ptr, this._dataHandle.AddrOfPinnedObject(), this._array.GetLength(1) * this._array.GetLength(2) * CvArray.SizeOfElement);
        }

        public Image(Image[] channels)


        {
            this.AllocateData(channels[0].Height, channels[0].Width, this.NumberOfChannels);
            if (this.NumberOfChannels == 1)
            {
                CvInvoke.cvCopy(channels[0].Ptr, base.Ptr, IntPtr.Zero);
                return;
            }
            int num = channels.Length;
            CvInvoke.cvMerge((num > 0) ? channels[0].Ptr : IntPtr.Zero, (num > 1) ? channels[1].Ptr : IntPtr.Zero, (num > 2) ? channels[2].Ptr : IntPtr.Zero, (num > 3) ? channels[3].Ptr : IntPtr.Zero, base.Ptr);
        }

        public Image(SerializationInfo info, StreamingContext context)


        {
            this.DeserializeObjectData(info, context);
            this.ROI = (Rectangle)info.GetValue("Roi", typeof(Rectangle));
        }

        [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]


        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (this.IsROISet)
            {
                Rectangle rOI = this.ROI;
                this.ROI = Rectangle.Empty;
                base.GetObjectData(info, context);
                this.ROI = rOI;
                info.AddValue("Roi", rOI);
                return;
            }
            base.GetObjectData(info, context);
            info.AddValue("Roi", this.ROI);
        }

        public TColor GetAverage()


        {
            return this.GetAverage(null);
        }

        public TColor GetAverage(Image mask)


        {
            TColor result = default(TColor);
            result.MCvScalar = CvInvoke.cvAvg(base.Ptr, (mask == null) ? IntPtr.Zero : mask.Ptr);
            return result;
        }

        public TColor GetSum()


        {
            TColor result = default(TColor);
            result.MCvScalar = CvInvoke.cvSum(base.Ptr);
            return result;
        }

        public void SetValue(TColor color)


        {
            base.SetValue(color.MCvScalar);
        }

        public void SetValue(TColor color, Image mask)


        {
            base.SetValue(color.MCvScalar, mask);
        }

        public void Copy(Image dest, Image mask)


        {
            CvInvoke.cvCopy(base.Ptr, dest.Ptr, (mask == null) ? IntPtr.Zero : mask.Ptr);
        }

        public Image Copy(Image mask)


        {
            Image image = new Image(base.Size);
            this.Copy(image, mask);
            return image;
        }

        public Image Copy(Rectangle roi)


        {
            Rectangle rOI = this.ROI;
            Image image = new Image(roi.Size);
            this.ROI = roi;
            CvInvoke.cvCopy(base.Ptr, image.Ptr, IntPtr.Zero);
            this.ROI = rOI;
            return image;
        }

        public Image Copy(MCvBox2D box)


        {
            PointF[] vertices = box.GetVertices();
            PointF[] dest = new PointF[]
            {
                new PointF(0f, box.size.Height - 1f),
                new PointF(0f, 0f),
                new PointF(box.size.Width - 1f, 0f)
            };
            Image result;
            using (RotationMatrix2D affineTransform = CameraCalibration.GetAffineTransform(vertices, dest))
            {
                Image image = new Image((int)box.size.Width, (int)box.size.Height);
                CvInvoke.cvWarpAffine(base.Ptr, image.Ptr, affineTransform.Ptr, 1, default(MCvScalar));
                result = image;
            }
            return result;
        }

        public Image Copy()


        {
            return this.Copy(null);
        }

        public Image CopyBlank()


        {
            return new Image(base.Size);
        }

        public Image Clone()


        {
            int coi = CvInvoke.cvGetImageCOI(base.Ptr);
            Rectangle rOI = this.ROI;
            CvInvoke.cvSetImageCOI(base.Ptr, 0);
            this.ROI = Rectangle.Empty;
            Image image = this.Copy();
            CvInvoke.cvSetImageCOI(image.Ptr, coi);
            image.ROI = rOI;
            CvInvoke.cvSetImageCOI(base.Ptr, coi);
            this.ROI = rOI;
            return image;
        }

        public Image GetSubRect(Rectangle rect)


        {
            Image image = new Image();
            image._array = this._array;
            GC.AddMemoryPressure((long)StructSize.MIplImage);
            image._ptr = CvToolbox.cvGetImageSubRect(this._ptr, ref rect);
            return image;
        }

        public virtual void Draw(Rectangle rect, TColor color, int thickness)


        {
            CvInvoke.cvRectangle(base.Ptr, rect.Location, Point.Add(rect.Location, rect.Size), color.MCvScalar, (thickness <= 0) ? -1 : thickness, LINE_TYPE.EIGHT_CONNECTED, 0);
        }

        public void Draw(Cross2DF cross, TColor color, int thickness)


        {
            if (thickness > 0)
            {
                this.Draw(cross.Horizontal, color, thickness);
                this.Draw(cross.Vertical, color, thickness);
            }
        }

        public virtual void Draw(LineSegment2DF line, TColor color, int thickness)


        {
            if (thickness > 0)
            {
                CvInvoke.cvLine(base.Ptr, Point.Round(line.P1), Point.Round(line.P2), color.MCvScalar, thickness, LINE_TYPE.EIGHT_CONNECTED, 0);
            }
        }        public virtual void Draw(LineSegment2D line, TColor color, int thickness)
        {
            if (thickness > 0)
            {
                CvInvoke.cvLine(base.Ptr, line.P1, line.P2, color.MCvScalar, thickness, LINE_TYPE.EIGHT_CONNECTED, 0);
            }
        }        public virtual void Draw(IConvexPolygonF polygon, TColor color, int thickness)
        {
            Point[] pts = Array.ConvertAll
(polygon.GetVertices(), new Converter
(Point.Round));
            if (thickness > 0)
            {
                this.DrawPolyline(pts, true, color, thickness);
                return;
            }
            this.FillConvexPoly(pts, color);
        }

        public void FillConvexPoly(Point[] pts, TColor color)


        {
            CvInvoke.cvFillConvexPoly(base.Ptr, pts, pts.Length, color.MCvScalar, LINE_TYPE.EIGHT_CONNECTED, 0);
        }

        public void DrawPolyline(Point[] pts, bool isClosed, TColor color, int thickness)


        {
            this.DrawPolyline(new Point[][]
            {
                pts
            }, isClosed, color, thickness);
        }

        public void DrawPolyline(Point[][] pts, bool isClosed, TColor color, int thickness)


        {
            if (thickness > 0)
            {
                GCHandle[] array = Array.ConvertAll
(pts, (Point[] polyline) => GCHandle.Alloc(polyline, GCHandleType.Pinned));
                CvInvoke.cvPolyLine(base.Ptr, Array.ConvertAll(array, (GCHandle h) => h.AddrOfPinnedObject()), Array.ConvertAll
int>(pts, (Point[] polyline) => polyline.Length), pts.Length, isClosed, color.MCvScalar, thickness, LINE_TYPE.EIGHT_CONNECTED, 0);
                GCHandle[] array2 = array;
                for (int i = 0; i < array2.Length; i++)
                {
                    GCHandle gCHandle = array2[i];
                    gCHandle.Free();
                }
            }
        }

        public virtual void Draw(CircleF circle, TColor color, int thickness)


        {
            CvInvoke.cvCircle(base.Ptr, Point.Round(circle.Center), (int)circle.Radius, color.MCvScalar, (thickness <= 0) ? -1 : thickness, LINE_TYPE.EIGHT_CONNECTED, 0);
        }        public void Draw(Ellipse ellipse, TColor color, int thickness)
        {
            CvInvoke.cvEllipseBox(base.Ptr, ellipse.MCvBox2D, color.MCvScalar, thickness, LINE_TYPE.EIGHT_CONNECTED, 0);
        }

        public virtual void Draw(string message, ref MCvFont font, Point bottomLeft, TColor color)


        {
            CvInvoke.cvPutText(base.Ptr, message, bottomLeft, ref font, color.MCvScalar);
        }

        public void Draw(Seq


c, TColor color, int thickness)
        {
            this.Draw(c, color, color, 0, thickness, Point.Empty);
        }

        public void Draw(Seq


c, TColor externalColor, TColor holeColor, int maxLevel, int thickness)
        {
            this.Draw(c, externalColor, holeColor, maxLevel, thickness, Point.Empty);
        }

        public void Draw(Seq


c, TColor externalColor, TColor holeColor, int maxLevel, int thickness, Point offset)
        {
            CvInvoke.cvDrawContours(base.Ptr, c.Ptr, externalColor.MCvScalar, holeColor.MCvScalar, maxLevel, thickness, LINE_TYPE.EIGHT_CONNECTED, offset);
        }

        public MCvAvgComp[][] DetectHaarCascade(HaarCascade haarObj)


        {
            return this.DetectHaarCascade(haarObj, 1.1, 3, HAAR_DETECTION_TYPE.DO_CANNY_PRUNING, new Size(0, 0));
        }

        public MCvAvgComp[][] DetectHaarCascade(HaarCascade haarObj, double scaleFactor, int minNeighbors, HAAR_DETECTION_TYPE flag, Size minSize)


        {
            Image.<>c__DisplayClass7 <>c__DisplayClass = new Image.<>c__DisplayClass7();
            <>c__DisplayClass.haarObj = haarObj;
            <>c__DisplayClass.scaleFactor = scaleFactor;
            <>c__DisplayClass.minNeighbors = minNeighbors;
            <>c__DisplayClass.flag = flag;
            <>c__DisplayClass.minSize = minSize;
            MCvAvgComp[][] result;
            using (MemStorage stor = new MemStorage())
            {
                Func conv = delegate(IImage img, int channel)
                {
                    IntPtr intPtr = CvInvoke.cvHaarDetectObjects(img.Ptr, <>c__DisplayClass.haarObj.Ptr, stor.Ptr, <>c__DisplayClass.scaleFactor, <>c__DisplayClass.minNeighbors, <>c__DisplayClass.flag, <>c__DisplayClass.minSize);
                    if (intPtr == IntPtr.Zero)
                    {
                        return new MCvAvgComp[0];
                    }
                    Seq seq = new Seq(intPtr, stor);
                    return seq.ToArray();
                };
                MCvAvgComp[][] array = this.ForEachDuplicateChannel(conv);
                result = array;
            }
            return result;
        }

        public LineSegment2D[][] HoughLinesBinary(double rhoResolution, double thetaResolution, int threshold, double minLineWidth, double gapBetweenLines)


        {
            Image.<>c__DisplayClassd <>c__DisplayClassd = new Image.<>c__DisplayClassd();
            <>c__DisplayClassd.rhoResolution = rhoResolution;
            <>c__DisplayClassd.thetaResolution = thetaResolution;
            <>c__DisplayClassd.threshold = threshold;
            <>c__DisplayClassd.minLineWidth = minLineWidth;
            <>c__DisplayClassd.gapBetweenLines = gapBetweenLines;
            LineSegment2D[][] result;
            using (MemStorage stor = new MemStorage())
            {
                result = this.ForEachDuplicateChannel(delegate(IImage img, int channel)
                {
                    IntPtr seq = CvInvoke.cvHoughLines2(img.Ptr, stor.Ptr, HOUGH_TYPE.CV_HOUGH_PROBABILISTIC, <>c__DisplayClassd.rhoResolution, <>c__DisplayClassd.thetaResolution, <>c__DisplayClassd.threshold, <>c__DisplayClassd.minLineWidth, <>c__DisplayClassd.gapBetweenLines);
                    Seq seq2 = new Seq(seq, stor);
                    return seq2.ToArray();
                });
            }
            return result;
        }

        public LineSegment2D[][] HoughLines(TColor cannyThreshold, TColor cannyThresholdLinking, double rhoResolution, double thetaResolution, int threshold, double minLineWidth, double gapBetweenLines)


        {
            LineSegment2D[][] result;
            using (Image image = this.Canny(cannyThreshold, cannyThresholdLinking))
            {
                result = image.HoughLinesBinary(rhoResolution, thetaResolution, threshold, minLineWidth, gapBetweenLines);
            }
            return result;
}

}

}


        


Додаток В

Підпрограма пошуку обличчя по ключових точках


headtrackr.getWhitebalance = function(canvas)

{

var avggray,avgr,avgb,avgg;



var canvasContext = canvas.getContext('2d');

var image = canvasContext.getImageData(0, 0, canvas.width, canvas.height);

var id = image.data;

var imagesize = image.width * image.height;

var r = g = b = 0;

for (var i = 0;i < imagesize;i++)

{

r += id[4*i];



g += id[(4*i)+1];

b += id[(4*i)+2];

}

avgr = r/imagesize;



avgg = g/imagesize;

avgb = b/imagesize;

avggray = (avgr+avgg+avgb)/3;

return avggray;

}

headtrackr.ccv.detect_objects = function (canvas, cascade, interval, min_neighbors)



{

var scale = Math.pow(2, 1 / (interval + 1));

var next = interval + 1;

var scale_upto = Math.floor(Math.log(Math.min(cascade.width, cascade.height)) / Math.log(scale));

var pyr = new Array((scale_upto + next * 2) * 4);

pyr[0] = canvas;

pyr[0].data = pyr[0].getContext("2d").getImageData(0, 0, pyr[0].width, pyr[0].height).data;

var i, j, k, x, y, q;

for (i = 1; i <= interval; i++) {

pyr[i * 4] = document.createElement("canvas");

pyr[i * 4].width = Math.floor(pyr[0].width / Math.pow(scale, i));

pyr[i * 4].height = Math.floor(pyr[0].height / Math.pow(scale, i));

pyr[i * 4].getContext("2d").drawImage(pyr[0], 0, 0, pyr[0].width, pyr[0].height, 0, 0, pyr[i * 4].width, pyr[i * 4].height);

pyr[i * 4].data = pyr[i * 4].getContext("2d").getImageData(0, 0, pyr[i * 4].width, pyr[i * 4].height).data;

}

for (i = next; i < scale_upto + next * 2; i++) {



pyr[i * 4] = document.createElement("canvas");

pyr[i * 4].width = Math.floor(pyr[i * 4 - next * 4].width / 2);

pyr[i * 4].height = Math.floor(pyr[i * 4 - next * 4].height / 2);

pyr[i * 4].getContext("2d").drawImage(pyr[i * 4 - next * 4], 0, 0, pyr[i * 4 - next * 4].width, pyr[i * 4 - next * 4].height, 0, 0, pyr[i * 4].width, pyr[i * 4].height);

pyr[i * 4].data = pyr[i * 4].getContext("2d").getImageData(0, 0, pyr[i * 4].width, pyr[i * 4].height).data;

}

for (i = next * 2; i < scale_upto + next * 2; i++) {



pyr[i * 4 + 1] = document.createElement("canvas");

pyr[i * 4 + 1].width = Math.floor(pyr[i * 4 - next * 4].width / 2);

pyr[i * 4 + 1].height = Math.floor(pyr[i * 4 - next * 4].height / 2);

pyr[i * 4 + 1].getContext("2d").drawImage(pyr[i * 4 - next * 4], 1, 0, pyr[i * 4 - next * 4].width - 1, pyr[i * 4 - next * 4].height, 0, 0, pyr[i * 4 + 1].width - 2, pyr[i * 4 + 1].height);

pyr[i * 4 + 1].data = pyr[i * 4 + 1].getContext("2d").getImageData(0, 0, pyr[i * 4 + 1].width, pyr[i * 4 + 1].height).data;

pyr[i * 4 + 2] = document.createElement("canvas");

pyr[i * 4 + 2].width = Math.floor(pyr[i * 4 - next * 4].width / 2);

pyr[i * 4 + 2].height = Math.floor(pyr[i * 4 - next * 4].height / 2);

pyr[i * 4 + 2].getContext("2d").drawImage(pyr[i * 4 - next * 4], 0, 1, pyr[i * 4 - next * 4].width, pyr[i * 4 - next * 4].height - 1, 0, 0, pyr[i * 4 + 2].width, pyr[i * 4 + 2].height - 2);

pyr[i * 4 + 2].data = pyr[i * 4 + 2].getContext("2d").getImageData(0, 0, pyr[i * 4 + 2].width, pyr[i * 4 + 2].height).data;

pyr[i * 4 + 3] = document.createElement("canvas");

pyr[i * 4 + 3].width = Math.floor(pyr[i * 4 - next * 4].width / 2);

pyr[i * 4 + 3].height = Math.floor(pyr[i * 4 - next * 4].height / 2);

pyr[i * 4 + 3].getContext("2d").drawImage(pyr[i * 4 - next * 4], 1, 1, pyr[i * 4 - next * 4].width - 1, pyr[i * 4 - next * 4].height - 1, 0, 0, pyr[i * 4 + 3].width - 2, pyr[i * 4 + 3].height - 2);

pyr[i * 4 + 3].data = pyr[i * 4 + 3].getContext("2d").getImageData(0, 0, pyr[i * 4 + 3].width, pyr[i * 4 + 3].height).data;

}

for (j = 0; j < cascade.stage_classifier.length; j++)



cascade.stage_classifier[j].orig_feature = cascade.stage_classifier[j].feature;

var scale_x = 1, scale_y = 1;

var dx = [0, 1, 0, 1];

var dy = [0, 0, 1, 1];

var seq = [];

for (i = 0; i < scale_upto; i++) {

var qw = pyr[i * 4 + next * 8].width - Math.floor(cascade.width / 4);

var qh = pyr[i * 4 + next * 8].height - Math.floor(cascade.height / 4);

var step = [pyr[i * 4].width * 4, pyr[i * 4 + next * 4].width * 4, pyr[i * 4 + next * 8].width * 4];

var paddings = [pyr[i * 4].width * 16 - qw * 16,

pyr[i * 4 + next * 4].width * 8 - qw * 8,

pyr[i * 4 + next * 8].width * 4 - qw * 4];

for (j = 0; j < cascade.stage_classifier.length; j++) {

var orig_feature = cascade.stage_classifier[j].orig_feature;

var feature = cascade.stage_classifier[j].feature = new Array(cascade.stage_classifier[j].count);

for (k = 0; k < cascade.stage_classifier[j].count; k++) {

feature[k] = {"size" : orig_feature[k].size,

"px" : new Array(orig_feature[k].size),

"pz" : new Array(orig_feature[k].size),

"nx" : new Array(orig_feature[k].size),

"nz" : new Array(orig_feature[k].size)};

for (q = 0; q < orig_feature[k].size; q++) {

feature[k].px[q] = orig_feature[k].px[q] * 4 + orig_feature[k].py[q] * step[orig_feature[k].pz[q]];

feature[k].pz[q] = orig_feature[k].pz[q];

feature[k].nx[q] = orig_feature[k].nx[q] * 4 + orig_feature[k].ny[q] * step[orig_feature[k].nz[q]];

feature[k].nz[q] = orig_feature[k].nz[q];

}

}

}



for (q = 0; q < 4; q++) {

var u8 = [pyr[i * 4].data, pyr[i * 4 + next * 4].data, pyr[i * 4 + next * 8 + q].data];

var u8o = [dx[q] * 8 + dy[q] * pyr[i * 4].width * 8, dx[q] * 4 + dy[q] * pyr[i * 4 + next * 4].width * 4, 0];

for (y = 0; y < qh; y++) {

for (x = 0; x < qw; x++) {

var sum = 0;

var flag = true;

for (j = 0; j < cascade.stage_classifier.length; j++) {

sum = 0;

var alpha = cascade.stage_classifier[j].alpha;

var feature = cascade.stage_classifier[j].feature;

for (k = 0; k < cascade.stage_classifier[j].count; k++) {

var feature_k = feature[k];

var p, pmin = u8[feature_k.pz[0]][u8o[feature_k.pz[0]] + feature_k.px[0]];

var n, nmax = u8[feature_k.nz[0]][u8o[feature_k.nz[0]] + feature_k.nx[0]];

if (pmin <= nmax) {

sum += alpha[k * 2];

} else {


var f, shortcut = true;

for (f = 0; f < feature_k.size; f++) {

if (feature_k.pz[f] >= 0) {

p = u8[feature_k.pz[f]][u8o[feature_k.pz[f]] + feature_k.px[f]];

if (p < pmin) {

if (p <= nmax) {

shortcut = false;

break;


}

pmin = p;

}

}

if (feature_k.nz[f] >= 0) {



n = u8[feature_k.nz[f]][u8o[feature_k.nz[f]] + feature_k.nx[f]];

if (n > nmax) {

if (pmin <= n) {

shortcut = false;

break;

}

nmax = n;



}

}

}



sum += (shortcut) ? alpha[k * 2 + 1] : alpha[k * 2];

}

}



if (sum < cascade.stage_classifier[j].threshold) {

flag = false;

break;

}

}



if (flag) {

seq.push({"x" : (x * 4 + dx[q] * 2) * scale_x,

"y" : (y * 4 + dy[q] * 2) * scale_y,

"width" : cascade.width * scale_x,

"height" : cascade.height * scale_y,

"neighbor" : 1,

"confidence" : sum});

}

u8o[0] += 16;



u8o[1] += 8;

u8o[2] += 4;

}

u8o[0] += paddings[0];



u8o[1] += paddings[1];

u8o[2] += paddings[2];

}

}

scale_x *= scale;



scale_y *= scale;

}

for (j = 0; j < cascade.stage_classifier.length; j++)



cascade.stage_classifier[j].feature = cascade.stage_classifier[j].orig_feature;

if (!(min_neighbors > 0))

return seq;

else {


var result = headtrackr.ccv.array_group(seq, function (r1, r2) {

var distance = Math.floor(r1.width * 0.25 + 0.5);


return r2.x <= r1.x + distance &&

r2.x >= r1.x - distance &&

r2.y <= r1.y + distance &&

r2.y >= r1.y - distance &&

r2.width <= Math.floor(r1.width * 1.5 + 0.5) &&

Math.floor(r2.width * 1.5 + 0.5) >= r1.width;

});

var ncomp = result.cat;



var idx_seq = result.index;

var comps = new Array(ncomp + 1);

for (i = 0; i < comps.length; i++)

comps[i] = {"neighbors" : 0,

"x" : 0,

"y" : 0,


"width" : 0,

"height" : 0,

"confidence" : 0};
for(i = 0; i < seq.length; i++)

{

var r1 = seq[i];



var idx = idx_seq[i];
if (comps[idx].neighbors == 0)

comps[idx].confidence = r1.confidence;


++comps[idx].neighbors;
comps[idx].x += r1.x;

comps[idx].y += r1.y;

comps[idx].width += r1.width;

comps[idx].height += r1.height;

comps[idx].confidence = Math.max(comps[idx].confidence, r1.confidence);

}
var seq2 = [];

for(i = 0; i < ncomp; i++)

{

var n = comps[i].neighbors;



if (n >= min_neighbors)

seq2.push({"x" : (comps[i].x * 2 + n) / (2 * n),

"y" : (comps[i].y * 2 + n) / (2 * n),

"width" : (comps[i].width * 2 + n) / (2 * n),

"height" : (comps[i].height * 2 + n) / (2 * n),

"neighbors" : comps[i].neighbors,

"confidence" : comps[i].confidence});

}
var result_seq = [];

for(i = 0; i < seq2.length; i++)

{

var r1 = seq2[i];



var flag = true;

for(j = 0; j < seq2.length; j++)

{

var r2 = seq2[j];



var distance = Math.floor(r2.width * 0.25 + 0.5);
if(i != j &&

r1.x >= r2.x - distance &&

r1.y >= r2.y - distance &&

r1.x + r1.width <= r2.x + r2.width + distance &&

r1.y + r1.height <= r2.y + r2.height + distance &&

(r2.neighbors > Math.max(3, r1.neighbors) || r1.neighbors < 3))

{

flag = false;



break;

}

}


if(flag)

result_seq.push(r1);

}

return result_seq;



}

};

headtrackr.cascade = {"count" : 16, "width" : 24, "height" : 24, "stage_classifier" :



[{"count":4,"threshold":-4.577530e+00,"feature":

[{"size":4,"px":[3,5,8,11],"py":[2,2,6,3],"pz":[2,1,1,0],"nx":[8,4,0,0],"ny":[4,4,0,0],"nz":[1,1,-1,-1]},

{"size":3,"px":[3,6,7],"py":[7,13,0],"pz":[1,0,-1],"nx":[2,3,4],"ny":[5,4,4],"nz":[2,1,1]},

{"size":5,"px":[5,3,10,13,11],"py":[1,0,3,2,2],"pz":[1,2,0,0,0],"nx":[0,11,0,11,11],"ny":[0,2,3,1,1],"nz":[1,1,0,1, -1]},

{"size":5,"px":[6,12,12,9,12],"py":[4,13,12,7,11],"pz":[1,0,0,1,0],"nx":[8,0,8,2,11],"ny":[4,0,8,5,1],"nz":[1,-1,-1,-1,-1]}],

"alpha":[-2.879683e+00,2.879683e+00,-1.569341e+00,1.569341e+00,-1.286131e+00,1.286131e+00,-1.157626e+00,1.157626e+00]},{"count":4,"threshold":-4.339908e+00,"feature":

[{"size":5,"px":[13,12,3,11,17],"py":[3,3,1,4,13],"pz":[0,0,2,0,0],"nx":[4,3,8,15,15],"ny":[4,5,4,8,8],"nz":[1,2,1,0,-1]},

{"size":5,"px":[6,7,6,3,3],"py":[13,13,4,2,7],"pz":[0,0,1,2,1],"nx":[4,8,3,0,15],"ny":[4,4,4,3,8],"nz":[1,1,-1,-1,-1]},

{"size":3,"px":[2,2,11],"py":[3,2,5],"pz":[2,2,0],"nx":[3,8,3],"ny":[4,4,4],"nz":[1,-1,-1]},

{"size":5,"px":[15,13,9,11,7],"py":[2,1,2,1,0],"pz":[0,0,0,0,1],"nx":[23,11,23,22,23],"ny":[1,0,2,0,0],"nz":[0,1,0,0,0]}],

"alpha":[-2.466029e+00,2.466029e+00,-1.839510e+00,1.839510e+00,-1.060559e+00,1.060559e+00,-1.094927e+00,1.094927e+00]},

{"count":7,"threshold":-5.052474e+00,"feature":

[{"size":5,"px":[17,13,3,11,10],"py":[13,2,1,4,3],"pz":[0,0,2,0,0],"nx":[4,8,8,3,7],"ny":[2,8,4,5,4],"nz":[2,0,1,2,1]},

{"size":5,"px":[6,7,3,6,6],"py":[4,12,2,13,14],"pz":[1,0,2,0,0],"nx":[8,3,4,4,3],"ny":[4,4,2,0,2],"nz":[1,1,-1,-1,-1]},

{"size":5,"px":[7,4,5,3,3],"py":[2,1,3,1,1],"pz":[0,1,0,1,-1],"nx":[1,0,1,1,0],"ny":[1,3,2,0,4],"nz":[0,0,0,0,0]},

{"size":5,"px":[11,11,11,3,2],"py":[11,13,10,7,2],"pz":[0,0,0,1,2],"nx":[4,1,8,2,0],"ny":[4,1,12,0,4],"nz":[1,-1,-1,-1,-1]},

{"size":3,"px":[9,13,1],"py":[7,19,4],"pz":[1,-1,-1],"nx":[4,7,4],"ny":[5,8,2],"nz":[2,1,2]},

{"size":5,"px":[12,8,16,4,4],"py":[12,1,2,0,0],"pz":[0,1,0,2,-1],"nx":[11,22,11,23,23],"ny":[2,0,1,1,5],"nz":[1,0,1,0,0]},

{"size":3,"px":[11,17,17],"py":[6,11,12],"pz":[0,0,0],"nx":[15,1,11],"ny":[9,1,1],"nz":[0,-1,-1]}],

"alpha":[-2.156890e+00,2.156890e+00,-1.718246e+00,1.718246e+00,-9.651329e-01,9.651329e-01,-9.948090e-01,9.948090e-01,-8.802466e-01,8.802466e-01,-8.486741e-01,8.486741e-01,-8.141777e-01,8.141777e-01]},

{"count":13,"threshold":-5.774400e+00,"feature":

[{"size":5,"px":[6,10,3,12,14],"py":[5,3,1,2,2],"pz":[1,0,2,0,0],"nx":[3,4,14,8,4],"ny":[5,4,8,4,2],"nz":[2,1,0,1,2]},

{"size":5,"px":[10,6,11,5,12],"py":[4,13,4,2,4],"pz":[0,0,0,1,0],"nx":[1,4,8,1,1],"ny":[2,4,4,4,3],"nz":[0,1,1,0,0]},

{"size":3,"px":[18,6,12],"py":[12,4,8],"pz":[0,1,0],"nx":[7,4,8],"ny":[4,2,4],"nz":[1,-1,-1]},

{"size":5,"px":[7,5,6,3,17],"py":[13,12,3,8,13],"pz":[0,0,1,1,0],"nx":[3,3,0,1,8],"ny":[4,5,5,10,4],"nz":[1,-1,-1,-1,-1]},

{"size":5,"px":[16,7,16,7,7],"py":[1,1,2,0,0],"pz":[0,1,0,1,-1],"nx":[23,23,23,11,5],"ny":[2,14,1,2,1],"nz":[0,0,0,1,2]},

{"size":3,"px":[9,18,16],"py":[7,14,2],"pz":[1,0,-1],"nx":[8,4,9],"ny":[10,2,4],"nz":[1,2,1]},

{"size":4,"px":[3,16,1,22],"py":[7,4,5,11],"pz":[1,-1,-1,-1],"nx":[3,9,4,2],"ny":[4,9,7,5],"nz":[1,0,1,2]},

{"size":5,"px":[4,7,8,8,9],"py":[0,2,2,1,1],"pz":[1,0,0,0,0],"nx":[0,0,1,0,0],"ny":[15,16,19,0,14],"nz":[0,0,0,1,0]},

{"size":5,"px":[4,4,7,8,12],"py":[2,5,6,7,10],"pz":[2,2,1,1,0],"nx":[8,5,10,0,0],"ny":[4,2,5,3,14],"nz":[1,-1,-1,-1,-1]},

{"size":2,"px":[11,0],"py":[13,4],"pz":[0,-1],"nx":[3,14],"ny":[4,16],"nz":[1,0]},

{"size":5,"px":[17,8,18,4,4],"py":[3,1,3,0,0],"pz":[0,1,0,2,-1],"nx":[21,22,5,11,22],"ny":[0,1,0,1,2],"nz":[0,0,2,1,0]},

{"size":4,"px":[7,8,2,11],"py":[13,12,2,7],"pz":[0,0,2,0],"nx":[4,0,23,3],"ny":[4,1,1,11],"nz":[1,-1,-1,-1]},

{"size":5,"px":[4,18,8,9,15],"py":[4,16,7,7,23],"pz":[2,0,1,1,0],"nx":[0,1,1,1,1],"ny":[10,21,23,22,22],"nz":[1,0,0,0,-1]}],

"alpha":[-1.956565e+00,1.956565e+00,-1.262438e+00,1.262438e+00,-1.056941e+00,1.056941e+00,-9.712509e-01,9.712509e-01,-8.261028e-01,8.261028e-01,-8.456506e-01,8.456506e-01,-6.652113e-01,6.652113e-01,-6.026287e-01,6.026287e-01,-6.915425e-01,6.915425e-01,-5.539286e-01,5.539286e-01,-5.515072e-01,5.515072e-01,-6.685884e-01,6.685884e-01,-4.656070e-01,4.656070e-01]},

{"count":20,"threshold":-5.606853e+00,"feature":

[{"size":5,"px":[17,11,6,14,9],"py":[13,4,4,3,3],"pz":[0,0,1,0,0],"nx":[14,4,8,7,8],"ny":[8,4,4,4,8],"nz":[0,1,1,1,0]},

{"size":5,"px":[3,9,10,11,11],"py":[7,2,2,3,3],"pz":[1,0,0,0,-1],"nx":[3,8,4,2,5],"ny":[4,4,10,2,8],"nz":[1,1,1,2,1]},

{"size":5,"px":[12,12,12,5,12],"py":[12,9,10,12,11],"pz":[0,0,0,0,0],"nx":[0,0,0,0,0],"ny":[2,1,3,0,0],"nz":[0,0,0,0,-1]},

{"size":5,"px":[9,18,9,9,12],"py":[7,14,19,5,11],"pz":[1,-1,-1,-1,-1],"nx":[23,4,23,23,8],"ny":[13,5,14,16,4],"nz":[0,2,0,0,1]},

{"size":5,"px":[12,12,12,6,1],"py":[13,11,12,6,5],"pz":[0,0,0,-1,-1],"nx":[4,6,8,4,9],"ny":[2,8,4,4,4],"nz":[2,1,1,1,1]},

{"size":4,"px":[12,11,11,6],"py":[5,5,6,13],"pz":[0,0,0,0],"nx":[8,3,2,8],"ny":[4,4,17,2],"nz":[1,1,-1,-1]},

{"size":5,"px":[3,14,12,15,13],"py":[0,2,2,2,2],"pz":[2,0,0,0,0],"nx":[22,23,22,23,7],"ny":[0,3,1,2,4],"nz":[0,0,0,0,1]},

{"size":5,"px":[16,15,18,19,9],"py":[12,11,12,12,9],"pz":[0,0,0,0,1],"nx":[8,2,22,23,21],"ny":[4,1,1,2,20],"nz":[1,-1,-1,-1,-1]},

{"size":3,"px":[4,7,7],"py":[0,2,2],"pz":[1,0,-1],"nx":[1,2,2],"ny":[2,0,2],"nz":[1,0,0]},

{"size":3,"px":[4,11,11],"py":[6,9,8],"pz":[1,0,0],"nx":[9,2,8],"ny":[9,4,5],"nz":[0,-1,-1]},

{"size":4,"px":[2,7,6,6],"py":[4,23,21,22],"pz":[2,0,0,0],"nx":[9,3,8,17],"ny":[21,2,5,1],"nz":[0,-1,-1,-1]},

{"size":2,"px":[2,8],"py":[4,12],"pz":[2,0],"nx":[3,0],"ny":[4,4],"nz":[1,-1]},

{"size":5,"px":[4,5,1,8,4],"py":[15,12,3,23,12],"pz":[0,0,2,0,0],"nx":[0,0,0,0,0],"ny":[23,10,22,21,11],"nz":[0,1,0,0,-1]},

{"size":2,"px":[21,5],"py":[13,4],"pz":[0,2],"nx":[23,4],"ny":[23,5],"nz":[0,-1]},

{"size":2,"px":[15,17],"py":[2,3],"pz":[0,0],"nx":[19,20],"ny":[2,1],"nz":[0,0]},

{"size":5,"px":[12,1,8,17,4],"py":[14,2,13,6,12],"pz":[0,-1,-1,-1,-1],"nx":[8,13,15,15,7],"ny":[10,9,15,14,8],"nz":[1,0,0,0,1]},

{"size":2,"px":[8,5],"py":[7,4],"pz":[1,-1],"nx":[4,13],"ny":[2,21],"nz":[2,0]},

{"size":2,"px":[3,4],"py":[7,0],"pz":[1,-1],"nx":[4,2],"ny":[7,5],"nz":[1,2]},

{"size":4,"px":[4,14,3,11],"py":[3,23,2,5],"pz":[2,0,2,0],"nx":[7,8,2,16],"ny":[8,0,1,15],"nz":[0,-1,-1,-1]},

{"size":2,"px":[9,8],"py":[0,0],"pz":[0,0],"nx":[2,2],"ny":[3,5],"nz":[2,2]}],

"alpha":[-1.957970e+00,1.957970e+00,-1.225984e+00,1.225984e+00,-8.310246e-01,8.310246e-01,-8.315741e-01,8.315741e-01,-7.973616e-01,7.973616e-01,-7.661959e-01,7.661959e-01,-6.042118e-01,6.042118e-01,-6.506833e-01,6.506833e-01,-4.808219e-01,4.808219e-01,-6.079504e-01,6.079504e-01,-5.163994e-01,5.163994e-01,-5.268142e-01,5.268142e-01,-4.935685e-01,4.935685e-01,-4.427544e-01,4.427544e-01,-4.053949e-01,4.053949e-01,-4.701274e-01,4.701274e-01,-4.387648e-01,4.387648e-01,-4.305499e-01,4.305499e-01,-4.042607e-01,4.042607e-01,-4.372088e-01,4.372088e-01]},

{"count":22,"threshold":-5.679317e+00,"feature":[{"size":5,"px":[11,3,17,14,13],"py":[4,0,13,2,3],"pz":[0,2,0,0,0],"nx":[7,4,14,23,11],"ny":[8,4,8,4,0],"nz":[1,1,0,0,1]},{"size":5,"px":[7,12,6,12,12],"py":[12,8,3,10,9],"pz":[0,0,1,0,0],"nx":[4,9,8,15,15],"ny":[4,8,4,8,8],"nz":[1,0,1,0,-1]},{"size":3,"px":[4,2,10],"py":[1,4,1],"pz":[1,2,0],"nx":[2,3,8],"ny":[5,4,4],"nz":[2,1,-1]},{"size":5,"px":[3,17,6,6,16],"py":[2,12,4,14,12],"pz":[2,0,1,0,0],"nx":[8,3,7,5,15],"ny":[4,4,4,4,8],"nz":[1,1,-1,-1,-1]},{"size":5,"px":[5,6,7,4,8],"py":[3,3,3,1,3],"pz":[0,0,0,1,0],"nx":[0,0,0,0,1],"ny":[5,4,3,2,0],"nz":[0,0,0,0,0]},{"size":3,"px":[18,9,0],"py":[14,7,0],"pz":[0,1,-1],"nx":[8,14,8],"ny":[10,9,4],"nz":[1,0,1]},{"size":2,"px":[9,5],"py":[18,13],"pz":[0,0],"nx":[10,3],"ny":[16,4],"nz":[0,-1]},{"size":5,"px":[11,11,11,11,6],"py":[10,12,11,13,6],"pz":[0,0,0,0,-1],"nx":[5,21,22,22,22],"ny":[4,22,17,19,18],"nz":[2,0,0,0,0]},{"size":4,"px":[8,9,15,4],"py":[7,7,23,4],"pz":[1,1,0,2],"nx":[8,5,0,3],"ny":[4,18,4,9],"nz":[1,-1,-1,-1]},{"size":5,"px":[11,10,12,11,11],"py":[4,4,4,5,5],"pz":[0,0,0,0,-1],"nx":[4,6,8,2,8],"ny":[4,9,9,2,4],"nz":[1,1,0,2,1]},{"size":5,"px":[2,2,3,3,4],"py":[10,9,14,13,15],"pz":[1,1,0,0,0],"nx":[0,0,0,0,0],"ny":[5,9,10,19,18],"nz":[2,1,1,0,-1]},{"size":2,"px":[11,11],"py":[13,12],"pz":[0,0],"nx":[9,2],"ny":[15,2],"nz":[0,-1]},{"size":5,"px":[2,4,3,3,4],"py":[5,11,6,9,12],"pz":[1,0,1,0,0],"nx":[6,2,11,11,0],"ny":[9,1,5,20,18],"nz":[0,-1,-1,-1,-1]},{"size":5,"px":[18,9,17,19,16],"py":[2,0,2,2,1],"pz":[0,1,0,0,0],"nx":[22,23,11,23,23],"ny":[0,2,0,1,1],"nz":[0,0,1,0,-1]},{"size":5,"px":[5,5,6,7,6],"py":[17,16,15,23,22],"pz":[0,0,0,0,0],"nx":[7,6,2,5,23],"ny":[8,1,2,3,1],"nz":[0,-1,-1,-1,-1]},{"size":5,"px":[12,12,11,10,6],"py":[14,13,18,4,22],"pz":[0,-1,-1,-1,-1],"nx":[3,2,4,1,2],"ny":[19,4,23,13,16],"nz":[0,0,0,0,0]},{"size":4,"px":[11,16,11,17],"py":[7,11,8,12],"pz":[0,0,0,0],"nx":[7,14,10,4],"ny":[4,7,10,4],"nz":[1,0,-1,-1]},{"size":2,"px":[3,3],"py":[8,7],"pz":[1,1],"nx":[4,2],"ny":[10,2],"nz":[1,-1]},{"size":2,"px":[3,9],"py":[0,1],"pz":[1,0],"nx":[4,5],"ny":[1,0],"nz":[0,0]},{"size":2,"px":[14,16],"py":[3,3],"pz":[0,0],"nx":[9,14],"ny":[4,21],"nz":[1,0]},{"size":2,"px":[9,1],"py":[7,1],"pz":[1,-1],"nx":[8,9],"ny":[7,4],"nz":[1,1]},{"size":2,"px":[1,0],"py":[8,3],"pz":[0,2],"nx":[20,0],"ny":[3,3],"nz":[0,-1]}],

"alpha":[-1.581077e+00,1.581077e+00,-1.389689e+00,1.389689e+00,-8.733094e-01,8.733094e-01,-8.525177e-01,8.525177e-01,-7.416304e-01,7.416304e-01,-6.609002e-01,6.609002e-01,-7.119043e-01,7.119043e-01,-6.204438e-01,6.204438e-01,-6.638519e-01,6.638519e-01,-5.518876e-01,5.518876e-01,-4.898991e-01,4.898991e-01,-5.508243e-01,5.508243e-01,-4.635525e-01,4.635525e-01,-5.163159e-01,5.163159e-01,-4.495338e-01,4.495338e-01,-4.515036e-01,4.515036e-01,-5.130473e-01,5.130473e-01,-4.694233e-01,4.694233e-01,-4.022514e-01,4.022514e-01,-4.055690e-01,4.055690e-01,-4.151817e-01,4.151817e-01,-3.352302e-01,3.352302e-01]},

if(flag)


result_seq.push(r1);

}

return result_seq;



}

};

ДОДАТОК Г



Області застосування засобів відстеження переміщення обличчя



  • Охоронні системи.

  • Криміналістика.

  • Взаємодія комп'ютер – людина.

  • Віртуальна реальність.

  • Комп'ютерні ігри.

  • Контроль над імміграцією.

  • Соціальні сервіси.



Змн.
Арк.
докум.
Підпис
Дата
Арк.

1

08-23.МКР.013.00.000
08-08-ДР.032.00.000 ПЗ

Розробив

Тохтунов А.О.

Керівник

Мартинюк Т .Б.

Рецензент

Конлратенко Н.Р.

Н. контроль

Дзюбенко В. В.

Затверджую

Гороховський О.І
Відстежування переміщення обличчя людини на основі сегментації зображень
Літ.

Аркушів

7
ВНТУ,гр. 1КІ – 14м


Маса

Масштаб

Області застосування засобів відстеження переміщення обличчя


ДОДАТОК Д




    1. Локалізація обличчя людини (face localization).

    2. Відстеження переміщення обличчя людини (face tracking)
    Послідовність виявлення та відстеження переміщення обличчя


1   2   3   4   5   6   7   8   9



  • 1. Підстава для виконання магістерської кваліфікаційної роботи (МКР)
  • 2. Мета і призначення МКР
  • 3. Вихідні дані для виконання МКР
  • 4. Вимоги до виконання МКР
  • 5. Етапи МКР та очікувані результати
  • 7. Матеріали, що подаються до захисту МКР
  • 8. Порядок контролю виконання та захисту МКР
  • 9. Вимоги до оформлення МКР
  • 10. Вимоги щодо технічного захисту інформації в МКР з обмеженим доступом