Deepak Kumar's profile - activity

hi, can anybody explain me this code: this code is for counting number of finger. this is the input image

 // feature extraction.cpp : Defines the entry point for the console application.
//
//--------------------------------------In the name of GOD
//-------------------------------BOW+SVM by Mohammad Reza Mostajabi
//#include "stdafx.h"
#include <opencv\cv.h>
#include <opencv\highgui.h>
//#include <opencv\ml.h>
#include <stdio.h>
#include <iostream>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/nonfree/features2d.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2\ml\ml.hpp>
#include <vector>
using namespace cv;
using namespace std;

using std::cout;
using std::cerr;
using std::endl;
using std::vector;

RNG rnga(12345);



inline void mix_channels(cv::Mat const &src, cv::Mat &dst, std::initializer_list<int> from_to)
{
    cv::mixChannels(&src, 1, &dst, 1, std::begin(from_to), from_to.size() / 2);
}

double angle(std::vector<cv::Point>& contour, int pt, int r)
{
    int size = contour.size();
    cv::Point p0 = (pt>0) ? contour[pt%size] : contour[size - 1 + pt];
    cv::Point p1 = contour[(pt + r) % size];
    cv::Point p2 = (pt>r) ? contour[pt - r] : contour[size - 1 - r];

    double ux = p0.x - p1.x;
    double uy = p0.y - p1.y;
    double vx = p0.x - p2.x;
    double vy = p0.y - p2.y;
    return (ux*vx + uy*vy) / sqrt((ux*ux + uy*uy)*(vx*vx + vy*vy));
}

int rotation(std::vector<cv::Point>& contour, int pt, int r)
{
    int size = contour.size();
    cv::Point p0 = (pt>0) ? contour[pt%size] : contour[size - 1 + pt];
    cv::Point p1 = contour[(pt + r) % size];
    cv::Point p2 = (pt>r) ? contour[pt - r] : contour[size - 1 - r];

    double ux = p0.x - p1.x;
    double uy = p0.y - p1.y;
    double vx = p0.x - p2.x;
    double vy = p0.y - p2.y;
    return (ux*vy - vx*uy);
}

bool isEqual(double a, double b)
{
    return fabs(a - b) <= 1e-7;
}
int main()
{

    Mat input = imread("C:\\Users\\Intern-3\\Desktop\\IPF\\2.png");

    Size size = input.size();
    int erosion_size = 1;
    Mat HSV, threshold;
    cvtColor(input, HSV, COLOR_BGR2HSV);
    inRange(HSV, cv::Scalar(0, 0, 100), cv::Scalar(0, 0, 255), threshold);

    Mat erodeElement = getStructuringElement(MORPH_RECT, cv::Size(5, 5));
    Mat dilateElement = getStructuringElement(MORPH_RECT, cv::Size(8, 8));

    erode(threshold, threshold, erodeElement);

    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    Mat mask = threshold;
    findContours(mask.clone(), contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE, Point(0, 0));

    /// Draw contours
    Mat drawing = Mat::zeros(mask.size(), CV_8UC3);
    for (int i = 0; i< contours.size(); i++)
    {
        Scalar color = Scalar(rnga.uniform(0, 255), rnga.uniform(0, 255), rnga.uniform(0, 255));
        drawContours(drawing, contours, i, color, 2, 8, hierarchy, 0, Point());
    }
    cout << "Contours = " << contours.size() << endl;
    for (int i = 0; i < contours.size(); i++)
    {
        cout << "area : " << contourArea(contours[i]) << endl;
    }
    imshow("contour", drawing);

    if (!contours.empty())
    {
        for (int i = 0; i<contours.size(); i++)
        {
            if (cv::contourArea(contours[i])>500)
            {
                Point center;
                std::vector<cv::Point> fingers;
                std::vector<cv::Point> contour;

                cv::Moments m = cv::moments(contours[i]);
                center.x = m.m10 / m.m00;
                center.y = m.m01 / m.m00;

                for (int j ...

below is the code i am using for face detection. the porblem is that whenever the new frame arrives the face is detected in new windows each time. i want to display the frame in single windows. how can i do that.

thanks !!

code :

#include "stdafx.h"
#include <Windows.h>
#include <Kinect.h>
#include <Kinect.Face.h>
#include <opencv2/opencv.hpp>

#define _USE_MATH_DEFINES
#include <math.h>


template<class Interface>
inline void SafeRelease( Interface *& pInterfaceToRelease )
{
    if( pInterfaceToRelease != NULL ){
        pInterfaceToRelease->Release();
        pInterfaceToRelease = NULL;
    }
}

// Quote from Kinect for Windows SDK v2.0 Developer Preview - Samples/Native/FaceBasics-D2D, and Partial Modification
// ExtractFaceRotationInDegrees is: Copyright (c) Microsoft Corporation. All rights reserved.
inline void ExtractFaceRotationInDegrees( const Vector4* pQuaternion, int* pPitch, int* pYaw, int* pRoll )
{
    double x = pQuaternion->x;
    double y = pQuaternion->y;
    double z = pQuaternion->z;
    double w = pQuaternion->w;

    // convert face rotation quaternion to Euler angles in degrees
    *pPitch = static_cast<int>( std::atan2( 2 * ( y * z + w * x ), w * w - x * x - y * y + z * z ) / M_PI * 180.0f );
    *pYaw = static_cast<int>( std::asin( 2 * ( w * y - x * z ) ) / M_PI * 180.0f );
    *pRoll = static_cast<int>( std::atan2( 2 * ( x * y + w * z ), w * w + x * x - y * y - z * z ) / M_PI * 180.0f );
}

int _tmain( int argc, _TCHAR* argv[] )
{
    cv::setUseOptimized( true );

    // Sensor
    IKinectSensor* pSensor;
    HRESULT hResult = S_OK;
    hResult = GetDefaultKinectSensor( &pSensor );
    if( FAILED( hResult ) ){
        std::cerr << "Error : GetDefaultKinectSensor" << std::endl;
        return -1;
    }

    hResult = pSensor->Open();
    if( FAILED( hResult ) ){
        std::cerr << "Error : IKinectSensor::Open()" << std::endl;
        return -1;
    }

    // Source
    IColorFrameSource* pColorSource;
    hResult = pSensor->get_ColorFrameSource( &pColorSource );
    if( FAILED( hResult ) ){
        std::cerr << "Error : IKinectSensor::get_ColorFrameSource()" << std::endl;
        return -1;
    }

    IBodyFrameSource* pBodySource;
    hResult = pSensor->get_BodyFrameSource( &pBodySource );
    if( FAILED( hResult ) ){
        std::cerr << "Error : IKinectSensor::get_BodyFrameSource()" << std::endl;
        return -1;
    }

    // Reader
    IColorFrameReader* pColorReader;
    hResult = pColorSource->OpenReader( &pColorReader );
    if( FAILED( hResult ) ){
        std::cerr << "Error : IColorFrameSource::OpenReader()" << std::endl;
        return -1;
    }

    IBodyFrameReader* pBodyReader;
    hResult = pBodySource->OpenReader( &pBodyReader );
    if( FAILED( hResult ) ){
        std::cerr << "Error : IBodyFrameSource::OpenReader()" << std::endl;
        return -1;
    }

    // Description
    IFrameDescription* pDescription;
    hResult = pColorSource->get_FrameDescription( &pDescription );
    if( FAILED( hResult ) ){
        std::cerr << "Error : IColorFrameSource::get_FrameDescription()" << std::endl;
        return -1;
    }

    int width = 0;
    int height = 0;
    pDescription->get_Width( &width ); // 1920
    pDescription->get_Height( &height ); // 1080
    unsigned int bufferSize = width * height * 4 * sizeof( unsigned char );

    cv::Mat bufferMat( height, width, CV_8UC4 );
    cv::Mat faceMat( height / 2, width / 2, CV_8UC4 );
    cv::namedWindow( "Face" );

    // Color Table
    cv::Vec3b color[BODY_COUNT];
    color[0] = cv::Vec3b( 255, 0, 0 );
    color[1] = cv::Vec3b( 0, 255, 0 );
    color[2] = cv::Vec3b( 0, 0, 255 );
    color[3] = cv::Vec3b( 255, 255, 0 );
    color[4] = cv::Vec3b( 255, 0, 255 );
    color[5] = cv::Vec3b( 0, 255, 255 );

    // Coordinate Mapper
    ICoordinateMapper* pCoordinateMapper;
    hResult = pSensor->get_CoordinateMapper( &pCoordinateMapper );
    if( FAILED( hResult ) ){
        std::cerr << "Error : IKinectSensor::get_CoordinateMapper()" << std::endl;
        return -1;
    }

    IFaceFrameSource* pFaceSource[BODY_COUNT];
    DWORD features = FaceFrameFeatures::FaceFrameFeatures_BoundingBoxInColorSpace
        | FaceFrameFeatures::FaceFrameFeatures_PointsInColorSpace
        | FaceFrameFeatures::FaceFrameFeatures_RotationOrientation
        | FaceFrameFeatures::FaceFrameFeatures_Happy
        | FaceFrameFeatures::FaceFrameFeatures_RightEyeClosed
        | FaceFrameFeatures::FaceFrameFeatures_LeftEyeClosed
        | FaceFrameFeatures::FaceFrameFeatures_MouthOpen
        | FaceFrameFeatures::FaceFrameFeatures_MouthMoved
        | FaceFrameFeatures::FaceFrameFeatures_LookingAway
        | FaceFrameFeatures::FaceFrameFeatures_Glasses
        | FaceFrameFeatures::FaceFrameFeatures_FaceEngagement;
    IFaceFrameReader* pFaceReader[BODY_COUNT];
    for( int count = 0; count < BODY_COUNT; count++ ){
        // Source
        hResult = CreateFaceFrameSource( pSensor, 0, features, &pFaceSource[count] );
        if( FAILED( hResult ) ){
            std::cerr << "Error : CreateFaceFrameSource" << std::endl;
            return -1;
        }

        // Reader ...