SR300Camera.cpp dirty

#include "SR300Camera.h"
#include "RealSense/SenseManager.h"
#include "RealSense/SampleReader.h"
#include "util_render.h"


#include <iostream>

/***
Private constructor for the SR300 Camera depth sensor
***/
using namespace std;
using namespace Intel::RealSense;


SenseManager *pp = SenseManager::CreateInstance();
Capture::Device *device;
CaptureManager *cm;

const int depth_fps = 30;
const int depth_width = 640;
const int depth_height = 480;
cv::Size bufferSize;
const PXCCapture::Sample *sample;
std::vector<cv::Point3f> xyzBuffer;
const int NFrames = 400;
float* depthFrames = new float[NFrames*depth_width*depth_height];






SR300Camera::SR300Camera(bool use_live_sensor)
{

    CONFIDENCE_THRESHHOLD = (60.0f / 255.0f*500.0f);
    //INVALID_FLAG_VALUE = PMD_FLAG_INVALID;
    X_DIMENSION = depth_width;
    Y_DIMENSION = depth_height;

    int num_pixels = X_DIMENSION * Y_DIMENSION;
    Point3DF32* vertices = new Point3DF32[num_pixels];

    if (!use_live_sensor) {
        return;
    }

    int res;
    std::cout << "Trying to open SR300 camera\n";



    if (!pp) {
        wprintf_s(L"Unable to create the SenseManager\n");
    }

    /* Sets file recording or playback */
    cm = pp->QueryCaptureManager();
    //Status sts= STATUS_NO_ERROR;
    Status sts = STATUS_DATA_UNAVAILABLE; //mona is this the correct initialization?
    // Create stream renders
    UtilRender renderc(L"Color"), renderd(L"Depth"), renderi(L"IR"), renderr(L"Right"), renderl(L"Left");

    do {
        bool revert = false;
        /*
        DataDesc desc = {};

        if (cm->QueryCapture()) {
            cm->QueryCapture()->QueryDeviceInfo(0, &desc.deviceInfo);
        }
        else {
            //desc.deviceInfo.streams = Capture::STREAM_TYPE_COLOR | Capture::STREAM_TYPE_DEPTH;
            desc.deviceInfo.streams = Capture::STREAM_TYPE_DEPTH;
            revert = true;
        }
        */
        //pp->EnableStreams(&desc);
        pp->EnableStream(Capture::StreamType::STREAM_TYPE_DEPTH,
            X_DIMENSION, Y_DIMENSION, depth_fps);
        revert = true;
        sts = pp->Init();
        if (sts < Status::STATUS_NO_ERROR) {

            if (revert) {

                pp->Close();
                pp->EnableStream(Capture::STREAM_TYPE_DEPTH);
                sts = pp->Init();
                if (sts < Status::STATUS_NO_ERROR) {
                    pp->Close();
                    //pp->EnableStream(Capture::STREAM_TYPE_COLOR);
                    sts = pp->Init();
                }
            }
            if (sts < Status::STATUS_NO_ERROR) {
                wprintf_s(L"Failed to locate any video stream(s)\n");
                pp->Release();
            }
        }



        device = pp->QueryCaptureManager()->QueryDevice();

        device->ResetProperties(Capture::STREAM_TYPE_ANY);
        //cout << "accuracy is: "<<device->IVCAM_ACCURACY_MEDIAN;



        for (int nframes = 0; ; nframes++) {
            sts = pp->AcquireFrame(false);

            if (sts < Status::STATUS_NO_ERROR) {
                if (sts == Status::STATUS_STREAM_CONFIG_CHANGED) {
                    wprintf_s(L"Stream configuration was changed, re-initilizing\n");
                    pp->Close();
                }
                break;
            }

            sample = pp->QuerySample();

            //const Capture::Sample *sample = pp->QuerySample();
            if (sample) {
                cv::Mat img;
                //Copy all the vertices from Point3DF32 to the mat image
                //QueryVertices(Image *depth, Point3DF32 *vertices)
                //sample->color->QueryInfo()

                //cv::imshow("depth from OpenARK", Visualizer::visualizeDepthMap(img))
                if (sample->depth && !renderd.RenderFrame(sample->depth)) break;
                //if (sample->color && !renderc.RenderFrame(sample->color)) break;
                //if (sample->ir && !renderi.RenderFrame(sample->ir))    break;
                Image::ImageData depthImage;
                Image *depthMap = sample->depth;
                //depthMap->AcquireAccess(Image::ACCESS_READ, &depthImage);
                depthMap->AcquireAccess(Image::ACCESS_WRITE, &depthImage);
                memcpy(&depthFrames[nframes*Y_DIMENSION*X_DIMENSION], depthImage.planes[0], sizeof(float)*X_DIMENSION*Y_DIMENSION);
                Image::ImageInfo imgInfo = depthMap->QueryInfo();
                int depth_stride = depthImage.pitches[0] / sizeof(pxcU16);
                Projection * projection = device->CreateProjection();
                cout << "projection is: " << projection;
                cout << "device is: " << device;
                //int num_pixels = depth_height * depth_width;

                //projection->QueryVertices(depthMap, vertices);
                pxcU16 *dpixels = (pxcU16*)depthImage.planes[0];
                unsigned int dpitch = depthImage.pitches[0] / sizeof(pxcU16);

                /*for (int k = 0; k < num_pixels; k++) {
                    cout << "xx is " << vertices[k].x << endl;
                    cout << "yy is " << vertices[k].y << endl;
                    cout << "zz is " << vertices[k].z << endl;
                }*/
                //cout << "xx is " << vertices[0].x << endl;
                //cout << "yy is " << vertices[0].y << endl;
                //cout << "zz is " << vertices[0].z << endl;
                //cout << "*******************" << endl;

                Point3DF32* posUVZ = new Point3DF32[num_pixels];
                Point3DF32 *pos3D = new Point3DF32[num_pixels];

                for (int y = 0; y < Y_DIMENSION; y++) {
                    for (int x = 0; x < X_DIMENSION; x++) {
                        // populate the point with depth image pixel coordinates and the depth value
                        posUVZ[y*Y_DIMENSION + x].x = (pxcF32)x;
                        posUVZ[y*Y_DIMENSION + x].y = (pxcF32)y;
                        posUVZ[y*Y_DIMENSION + x].z = depthFrames[nframes*X_DIMENSION*Y_DIMENSION + y*Y_DIMENSION+ x];
                    }
                }

                //projection->ProjectDepthToCamera(num_pixels, posUVZ, pos3D);


                /*
                for (unsigned int yy = 0, k = 0; yy < Y_DIMENSION; yy++)
                {
                    for (unsigned int xx = 0; xx < X_DIMENSION; xx++, k++)
                    {
                        posUVZ[k].x = (pxcF32)xx;
                        posUVZ[k].y = (pxcF32)yy;
                        posUVZ[k].z = (pxcF32)dpixels[yy * dpitch + xx];
                            //  cout << "xx is " << posUVZ[k].x << endl;
                             // cout << "yy is " << posUVZ[k].y << endl;
                             // cout << "zz is " << posUVZ[k].z<< endl;
                    }
                }
                */




                // convert the array of depth coordinates + depth value (posUVZ) into the world coordinates (pos3D) in mm

                //Step 1: Set up the point cloud in camera coordinates and do the projection



                //projection->ProjectDepthToCamera(num_pixels, posUVZ, pos3D);

                if (projection->ProjectDepthToCamera(num_pixels, posUVZ, pos3D) < PXC_STATUS_NO_ERROR)
                {
                delete[] posUVZ;
                delete[] pos3D;
                cout << "projection unsucessful";
                return;
                }

                cout << "*************" << endl;
                for (unsigned int yy = 0, k = 0; yy < Y_DIMENSION; yy++)
                {
                    for (unsigned int xx = 0; xx < X_DIMENSION; xx++, k++)
                    {
                        cout << "xx is " << pos3D[k].x << endl;
                        cout << "yy is " << pos3D[k].y << endl;
                        cout << "zz is " << pos3D[k].z << endl;
                        xyzBuffer.push_back(cv::Point3f(pos3D[k].x, pos3D[k].y, pos3D[k].z));
                    }
                }
                cout << "/////////\\\\\\\\" << endl;
                projection->Release();
                depthMap->ReleaseAccess(&depthImage); //is this in the right place mona?

            }
            printf("opened sensor\n");
            pp->ReleaseFrame();
            printf("acquired image\n");

        }

    } while (sts == Status::STATUS_STREAM_CONFIG_CHANGED);

    //numRows = width and numCol = height? ?
    //numPixels = dd.img.numRows * dd.img.numColumns; // Number of pixels in camera
    numPixels = depth_width * depth_height;
    dists = new float[3 * numPixels]; // Dists contains XYZ values. needs to be 3x the size of numPixels
    amps = new float[numPixels];
    //frame = cvCreateImage(cvSize(dd.img.numColumns, dd.img.numRows), 8, 3); // Create the frame
    frame = cvCreateImage(cvSize(depth_width, depth_height), 8, 3); // Create the frame

    KF.init(6, 3, 0);
    KF.transitionMatrix = (cv::Mat_<float>(6, 6) << 1, 0, 0, 1, 0, 0,
                                                    0, 1, 0, 0, 1, 0,
                                                    0, 0, 1, 0, 0, 1,
                                                    0, 0, 0, 1, 0, 0,
                                                    0, 0, 0, 0, 1, 0,
                                                    0, 0, 0, 0, 0, 1);
    measurement = cv::Mat_<float>::zeros(3, 1);

    //Initaite Kalman
    KF.statePre.setTo(0);
    setIdentity(KF.measurementMatrix);
    setIdentity(KF.processNoiseCov, cv::Scalar::all(.001)); // Adjust this for faster convergence - but higher noise
    setIdentity(KF.measurementNoiseCov, cv::Scalar::all(1e-1));
    setIdentity(KF.errorCovPost, cv::Scalar::all(.1));

    /* mona will test this
    setIdentity(KF.measurementMatrix);
    setIdentity(KF.processNoiseCov, Scalar::all(smoothness));
    setIdentity(KF.measurementNoiseCov, Scalar::all(rapidness));
    setIdentity(KF.errorCovPost, Scalar::all(.1));
    */
}

/***
Public deconstructor for the SR300 Camera depth sensor
***/
SR300Camera::~SR300Camera() {};

void SR300Camera::destroyInstance()
{
    printf("closing sensor\n");
    pp->Release();
    printf("sensor closed\n");
}

/***
Create xyzMap, zMap, ampMap, and flagMap from sensor input
***/
void SR300Camera::update()
{
    initilizeImages();

    fillInAmps();
}



/***
Reads the amplitude data from the sensor and fills in the matrix
***/
void SR300Camera::fillInAmps()
{
    //int res = pmdGetAmplitudes(hnd, amps, numPixels * sizeof(float));
    //float * dataPtr = amps;
    //ampMap.data = (uchar *)amps;
}

/***
Returns the X value at (i, j)
***/
float SR300Camera::getX(int i, int j) const
{
    //int flat = j * dd.img.numColumns * 3 + i * 3;
    int flat = j * depth_width * 3 + i * 3;
    return dists[flat];
}

/***
Returns the Y value at (i, j)
***/
float SR300Camera::getY(int i, int j) const
{
    //int flat = j * dd.img.numColumns * 3 + i * 3;
    int flat = j * depth_width * 3 + i * 3;
    return dists[flat + 1];
}

/***
Returns the Z value at (i, j)
***/
float SR300Camera::getZ(int i, int j) const
{
    //int flat = j * dd.img.numColumns * 3 + i * 3;
    int flat = j * depth_width * 3 + i * 3;
    return dists[flat + 2];
}