void Kinect::KinectHandTracker::getAllHands() { // List of hands evidence // If hand matches old positions, previous ID is assigned again const nite::Array<nite::HandData>& hands= this->handTrackerFrame.getHands(); //printf("%d hands\n", hands.getSize()); this->isTwoHands = false; for (int i = 0; i < hands.getSize(); ++i) { const nite::HandData& user = hands[i]; if (!user.isTracking()) { //printf("Lost hand %d\n", user.getId()); nite::HandId id = user.getId(); HistoryBuffer<20>* pHistory = this->g_histories[id]; this->g_histories.erase(this->g_histories.find(id)); delete pHistory; } else { if (user.isNew()) { //printf("New hand id %d\n", user.getId()); this->g_histories[user.getId()] = new HistoryBuffer<20>; } // Hand evidence in Buffer HistoryBuffer<20>* pHistory = this->g_histories[user.getId()]; pHistory->AddPoint(user.getPosition()); // Data for mouse //first find HAND = MOUSE if(i==0 && isCursorMovementEnable) { mouse->setSpeedUpMoving(mSpeed); //mouse->moveCursorMouse(user.getPosition().x/2,-1.0*user.getPosition().y/2,isClick); coordinateConverter.convertWorldToDepth(*mDepth, user.getPosition().x, user.getPosition().y, user.getPosition().z, &mDepthX, &mDepthY, &mDepthZ); mouse->moveCursorWorldCoordinates(mDepthX,mDepthY,isClick); } // TODO - further implementation should include depth information in pixels this->handZ[i] = user.getPosition().z; this->getArrayHands[i][0] = user.getPosition().x; this->getArrayHands[i][1] = 0 - user.getPosition().y; // If two hands have been found get the position of the rectangle if (hands.getSize() == 2) { printf("two hands found\n"); // get positions for both hands this->isTwoHands = true; } } } }
void Init(float lengthInSeconds, float updateRateInHz, float attackTime, float releaseTime, float samplerate) { attack = 1.0f - powf(0.01f, 1.0f / (samplerate * attackTime)); release = 1.0f - powf(0.01f, 1.0f / (samplerate * releaseTime)); updateperiod = samplerate / updateRateInHz; int length = (int)ceilf(lengthInSeconds * updateRateInHz); peakbuf.Init(length); rmsbuf.Init(length); }
status_t BasicTerminalBuffer::_ResizeHistory(int32 width, int32 historyCapacity) { if (width == fWidth && historyCapacity == HistoryCapacity()) return B_OK; if (historyCapacity <= 0) { // new history capacity is 0 -- delete the old history object delete fHistory; fHistory = NULL; return B_OK; } HistoryBuffer* history = new(std::nothrow) HistoryBuffer; if (history == NULL) return B_NO_MEMORY; status_t error = history->Init(width, historyCapacity); if (error != B_OK) { delete history; return error; } // Transfer the lines from the old history to the new one. if (fHistory != NULL) { int32 historySize = min_c(HistorySize(), historyCapacity); TerminalLine* lineBuffer = ALLOC_LINE_ON_STACK(fWidth); for (int32 i = historySize - 1; i >= 0; i--) { TerminalLine* line = fHistory->GetTerminalLineAt(i, lineBuffer); if (line->length > width) _TruncateLine(line, width); history->AddLine(line); } } delete fHistory; fHistory = history; return B_OK; }
inline void Feed(const float* inputs, int numchannels) { float maxPeak = 0.0f, maxRMS = 0.0f; for (int i = 0; i < numchannels; i++) { float x = inputs[i]; x = fabsf(x); peak[i] += (x - peak[i]) * ((x > peak[i]) ? attack : release); x *= x; rms[i] += (x - rms[i]) * ((x > rms[i]) ? attack : release); if (peak[i] > maxPeak) maxPeak = peak[i]; if (rms[i] > maxRMS) maxRMS = rms[i]; } if (--updatecount <= 0.0f) { updatecount += updateperiod; peakbuf.Feed(maxPeak); rmsbuf.Feed(sqrtf(maxRMS)); } }
void SampleViewer::Display() { nite::Status rc = m_pHandTracker->readFrame(&handFrame); if (rc != nite::STATUS_OK) { printf("GetNextData failed\n"); return; } depthFrame = handFrame.getDepthFrame(); if (m_pTexMap == NULL) { // Texture map init m_nTexMapX = MIN_CHUNKS_SIZE(depthFrame.getVideoMode().getResolutionX(), TEXTURE_SIZE); m_nTexMapY = MIN_CHUNKS_SIZE(depthFrame.getVideoMode().getResolutionY(), TEXTURE_SIZE); m_pTexMap = new openni::RGB888Pixel[m_nTexMapX * m_nTexMapY]; } glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0, GL_WIN_SIZE_X, GL_WIN_SIZE_Y, 0, -10000.0, 10000.0); if (depthFrame.isValid()) { calculateHistogram(m_pDepthHist, MAX_DEPTH, depthFrame); } memset(m_pTexMap, 0, m_nTexMapX*m_nTexMapY*sizeof(openni::RGB888Pixel)); float factor[3] = {1, 1, 1}; // check if we need to draw depth frame to texture float av_x = 0; float av_y = 0; int counter= 0; for(int i = 0; i<=7 ; i++) note_on[i] = false; if (depthFrame.isValid() && g_drawDepth) { const openni::DepthPixel* pDepthRow = (const openni::DepthPixel*)depthFrame.getData(); const openni::DepthPixel* pDepthRow1 = pDepthRow; openni::RGB888Pixel* pTexRow = m_pTexMap + depthFrame.getCropOriginY() * m_nTexMapX; int rowSize = depthFrame.getStrideInBytes() / sizeof(openni::DepthPixel); glPointSize(2); glBegin(GL_POINTS); for (int y = 0; y < depthFrame.getHeight(); ++y) { const openni::DepthPixel* pDepth = pDepthRow; openni::RGB888Pixel* pTex = pTexRow + depthFrame.getCropOriginX(); //chord_temp = 0; for (int x = 0; x < depthFrame.getWidth(); ++x, ++pDepth, ++pTex) { if (*pDepth != 0) { factor[0] = Colors[colorCount][0]; factor[1] = Colors[colorCount][1]; factor[2] = Colors[colorCount][2]; int nHistValue = m_pDepthHist[*pDepth]; pTex->r = nHistValue*factor[0]; pTex->g = nHistValue*factor[1]; pTex->b = nHistValue*factor[2]; factor[0] = factor[1] = factor[2] = 1; if(*pDepth <= 800) { //glColor3f(1,0,0); glColor3f(float(*pDepth)/2000,float(*pDepth)/2000,float(*pDepth)/2000); av_x = x + av_x; counter++; av_y = y + av_y; } else{ glColor3f(float(*pDepth)/2000,float(*pDepth)/2000,float(*pDepth)/2000); } glVertex3f(2*x,2*y,-*pDepth); } } pDepthRow += rowSize; pTexRow += m_nTexMapX; } glEnd(); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// av_x = av_x / counter; av_y = av_y / counter; float R_x=0; float R_y=0; float L_x=0; float L_y=0; int counter_R=0; int counter_L=0; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// for (int y = 0; y < depthFrame.getHeight(); ++y) { const openni::DepthPixel* pDepth = pDepthRow1; //chord_temp = 0; for (int x = 0; x < depthFrame.getWidth(); ++x, ++pDepth) { if (*pDepth != 0) { if(*pDepth <= 800) { if(x > av_x){ counter_R++; R_x = R_x +x; R_y = R_y +y; } if(x < av_x){ counter_L++; L_x = L_x +x; L_y = L_y +y; } } } } pDepthRow1 += rowSize; } ///////////////////////////////////////////////////////////////// R_x = R_x/counter_R; R_y = R_y/counter_R; L_x = L_x/counter_L; L_y = L_y/counter_L; glPointSize(30); glBegin(GL_POINTS); glColor3f(1,0,0); glVertex3f(R_x*2,R_y*2,800); glColor3f(1,1,0); glVertex3f(L_x*2,L_y*2,800); glEnd(); if( R_x >=75 && R_x <=175 ){ if( R_y <= 150 ) { note_on[0] = true; } else if( R_y >= 350) { note_on[1] = true; } } if( R_x >=175 && R_x <=300){ if( R_y <= 150 ) { note_on[2] = true; } else if( R_y >= 350 ) { note_on[3] = true; } } if( R_x>=300 && R_x<=425){ if( R_y <= 150 ) { note_on[4] = true; } else if( R_y >= 350 ) { note_on[5] = true; } } if( R_x>=425 && R_x<=550){ if( R_y <= 150 ) { note_on[6] = true; } else if( R_y >= 350 ) { note_on[7] = true; } } //////////////////////////////////////// if( L_x >=75 && L_x <=175 ){ if( L_y <= 150 ) { note_on[0] = true; } else if( L_y >= 350) { note_on[1] = true; } } if( L_x >=175 && L_x <=300){ if( L_y <= 150 ) { note_on[2] = true; } else if( L_y >= 350 ) { note_on[3] = true; } } if( L_x>=300 && L_x<=425){ if( L_y <= 150 ) { note_on[4] = true; } else if( L_y >= 350 ) { note_on[5] = true; } } if( L_x>=425 && L_x<=550){ if( L_y <= 150 ) { note_on[6] = true; } else if( L_y >= 350 ) { note_on[7] = true; } } } playdrum(); for(int i=0;i<=7 ;i++) last_note[i] = note_on[i]; glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, BMPwidth1,BMPheight1, 0, GL_RGB, GL_UNSIGNED_BYTE, BMPimage1); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(1,1,1,0.5); glEnable(GL_TEXTURE_2D); glBegin(GL_QUADS); g_nXRes = depthFrame.getVideoMode().getResolutionX(); g_nYRes = depthFrame.getVideoMode().getResolutionY(); // upper left glTexCoord2f(0,1); glVertex3f(0,0,-800); // upper right glTexCoord2f(1,1); glVertex3f(1240,0,-800); // bottom right glTexCoord2f(1,0); glVertex3f(1240,960,-800); // bottom left glTexCoord2f(0,0); glVertex3f(0,960,-800); glEnd(); glDisable(GL_TEXTURE_2D); glDisable(GL_BLEND); /////////////////////////////////////////////////////////////////////////////////chord selection glBegin(GL_LINES); glColor3f(1,0,0); glVertex3f(150,300,800); glVertex3f(1100,300,800); glVertex3f(150,700,800); glVertex3f(1100,700,800); glEnd(); glPointSize(30); glBegin(GL_POINTS); glColor3f(1,1,0); glVertex3f(150,300,800); glVertex3f(350,300,800); glVertex3f(600,300,800); glVertex3f(850,300,800); glVertex3f(1100,300,800); glVertex3f(150,700,800); glVertex3f(350,700,800); glVertex3f(600,700,800); glVertex3f(850,700,800); glVertex3f(1100,700,800); glEnd(); //////////////////////////////////////////////////////////////////////////////////////////////////////////// const nite::Array<nite::GestureData>& gestures = handFrame.getGestures(); for (int i = 0; i < gestures.getSize(); ++i) { if (gestures[i].isComplete()) { const nite::Point3f& position = gestures[i].getCurrentPosition(); printf("Gesture %d at (%f,%f,%f)\n", gestures[i].getType(), position.x, position.y, position.z); nite::HandId newId; m_pHandTracker->startHandTracking(gestures[i].getCurrentPosition(), &newId); } } const nite::Array<nite::HandData>& hands= handFrame.getHands(); for (int i = 0; i < hands.getSize(); ++i) { const nite::HandData& user = hands[i]; if (!user.isTracking()) { printf("Lost hand %d\n", user.getId()); nite::HandId id = user.getId(); HistoryBuffer<20>* pHistory = g_histories[id]; g_histories.erase(g_histories.find(id)); delete pHistory; } else { if (user.isNew()) { printf("Found hand %d\n", user.getId()); g_histories[user.getId()] = new HistoryBuffer<20>; } // Add to history HistoryBuffer<20>* pHistory = g_histories[user.getId()]; pHistory->AddPoint(user.getPosition()); // Draw history DrawHistory(m_pHandTracker, user.getId(), pHistory); } } if (g_drawFrameId) { DrawFrameId(handFrame.getFrameIndex()); } // Swap the OpenGL display buffers glutSwapBuffers(); }
void HandGesture::Display() { nite::HandTrackerFrameRef handFrame; openni::VideoFrameRef depthFrame; nite::Status rc = m_pHandTracker->readFrame(&handFrame); IplImage* pDepthImg = cvCreateImage(cvSize(W,H), IPL_DEPTH_16U, 1); if (rc != nite::STATUS_OK) { printf("GetNextData failed\n"); return; } depthFrame = handFrame.getDepthFrame(); if (depthFrame.isValid()) { // calculateHistogram(m_pDepthHist, MAX_DEPTH, depthFrame); // getHandThreshold(depthFrame); /*Copy depth data to image data*/ memcpy(pDepthImg->imageData, depthFrame.getData(), W*H*2); cvCvtScale(pDepthImg, this->pImg, DEPTH_SCALE_FACTOR); cvConvertImage(this->pImg, this->pRgbImg, CV_GRAY2RGB); } const nite::Array<nite::GestureData>& gestures = handFrame.getGestures(); for (int i = 0; i < gestures.getSize(); ++i) { if (gestures[i].isComplete()) { nite::HandId newId; m_pHandTracker->startHandTracking(gestures[i].getCurrentPosition(), &newId); } } const nite::Array<nite::HandData>& hands= handFrame.getHands(); CvPoint2D32f handPoint = cvPoint2D32f(0,0); CvPoint cvhandPoint = cvPoint(0, 0); for (int i = 0; i < hands.getSize(); ++i) { const nite::HandData& hand = hands[i]; if (!hand.isTracking())// Tracking hand is lost { printf("Lost hand %d\n", hand.getId()); nite::HandId id = hand.getId(); HistoryBuffer<HISBUFFER>* pHistory = g_histories[id]; g_histories.erase(g_histories.find(id)); delete pHistory; handPointClear(); } else { if (hand.isNew()) { printf("Found hand %d\n", hand.getId()); nite::HandId id = hand.getId(); g_histories[hand.getId()] = new HistoryBuffer<HISBUFFER>; handPoint = cvPoint2D32f(0,0); cvhandPoint = cvPoint(0, 0); } this->hand3DPoint = hand.getPosition(); // Add to history HistoryBuffer<HISBUFFER>* pHistory = g_histories[hand.getId()]; pHistory->AddPoint(hand.getPosition()); // Draw history DrawHistory(m_pHandTracker, hand.getId(), pHistory); //Get coordiation of hand point m_pHandTracker->convertHandCoordinatesToDepth(hand3DPoint.x, hand3DPoint.y, hand3DPoint.z, (float*)&handPoint.x, (float*)&handPoint.y); // Convert hand point to int cvhandPoint = cvPointFrom32f(handPoint); printf("Gesture %d at (%d,%d,%d)\n", hand.getId(), cvhandPoint.x, cvhandPoint.y, handDepthPoint.d); getHandThreshold(depthFrame); cvShowImage("ThresholdImage", this->pThImg); cvCircle(this->pRgbImg, cvhandPoint, 2, RED, 4, CV_AA, 0); } } cvShowImage("DepthImage", this->pRgbImg); }
status_t BasicTerminalBuffer::_ResizeRewrap(int32 width, int32 height, int32 historyCapacity) { //debug_printf("BasicTerminalBuffer::_ResizeRewrap(): (%ld, %ld, history: %ld) -> " //"(%ld, %ld, history: %ld)\n", fWidth, fHeight, HistoryCapacity(), width, height, //historyCapacity); // The width stays the same. _ResizeSimple() does exactly what we need. if (width == fWidth) return _ResizeSimple(width, height, historyCapacity); // The width changes. We have to allocate a new line array, a new history // and re-wrap all lines. TerminalLine** screen = _AllocateLines(width, height); if (screen == NULL) return B_NO_MEMORY; HistoryBuffer* history = NULL; if (historyCapacity > 0) { history = new(std::nothrow) HistoryBuffer; if (history == NULL) { _FreeLines(screen, height); return B_NO_MEMORY; } status_t error = history->Init(width, historyCapacity); if (error != B_OK) { _FreeLines(screen, height); delete history; return error; } } int32 historySize = HistorySize(); int32 totalLines = historySize + fHeight; // re-wrap TerminalLine* lineBuffer = ALLOC_LINE_ON_STACK(fWidth); TermPos cursor; int32 destIndex = 0; int32 sourceIndex = 0; int32 sourceX = 0; int32 destTotalLines = 0; int32 destScreenOffset = 0; int32 maxDestTotalLines = INT_MAX; bool newDestLine = true; bool cursorSeen = false; TerminalLine* sourceLine = _HistoryLineAt(-historySize, lineBuffer); while (sourceIndex < totalLines) { TerminalLine* destLine = screen[destIndex]; if (newDestLine) { // Clear a new dest line before using it. If we're about to // overwrite an previously written line, we push it to the // history first, though. if (history != NULL && destTotalLines >= height) history->AddLine(screen[destIndex]); destLine->Clear(fAttributes, width); newDestLine = false; } int32 sourceLeft = sourceLine->length - sourceX; int32 destLeft = width - destLine->length; //debug_printf(" source: %ld, left: %ld, dest: %ld, left: %ld\n", //sourceIndex, sourceLeft, destIndex, destLeft); if (sourceIndex == historySize && sourceX == 0) { destScreenOffset = destTotalLines; if (destLeft == 0 && sourceLeft > 0) destScreenOffset++; maxDestTotalLines = destScreenOffset + height; //debug_printf(" destScreenOffset: %ld\n", destScreenOffset); } int32 toCopy = min_c(sourceLeft, destLeft); // If the last cell to copy is the first cell of a // full-width char, don't copy it yet. if (toCopy > 0 && IS_WIDTH( sourceLine->cells[sourceX + toCopy - 1].attributes)) { //debug_printf(" -> last char is full-width -- don't copy it\n"); toCopy--; } // translate the cursor position if (fCursor.y + historySize == sourceIndex && fCursor.x >= sourceX && (fCursor.x < sourceX + toCopy || (destLeft >= sourceLeft && sourceX + sourceLeft <= fCursor.x))) { cursor.x = destLine->length + fCursor.x - sourceX; cursor.y = destTotalLines; if (cursor.x >= width) { // The cursor was in free space after the official end // of line. cursor.x = width - 1; } //debug_printf(" cursor: (%ld, %ld)\n", cursor.x, cursor.y); cursorSeen = true; } if (toCopy > 0) { memcpy(destLine->cells + destLine->length, sourceLine->cells + sourceX, toCopy * sizeof(TerminalCell)); destLine->length += toCopy; } destLine->attributes = sourceLine->attributes; bool nextDestLine = false; if (toCopy == sourceLeft) { if (!sourceLine->softBreak) nextDestLine = true; sourceIndex++; sourceX = 0; sourceLine = _HistoryLineAt(sourceIndex - historySize, lineBuffer); } else { destLine->softBreak = true; nextDestLine = true; sourceX += toCopy; } if (nextDestLine) { destIndex = (destIndex + 1) % height; destTotalLines++; newDestLine = true; if (cursorSeen && destTotalLines >= maxDestTotalLines) break; } } // If the last source line had a soft break, the last dest line // won't have been counted yet. if (!newDestLine) { destIndex = (destIndex + 1) % height; destTotalLines++; } //debug_printf(" total lines: %ld -> %ld\n", totalLines, destTotalLines); if (destTotalLines - destScreenOffset > height) destScreenOffset = destTotalLines - height; cursor.y -= destScreenOffset; // When there are less lines (starting with the screen offset) than // there's room in the screen, clear the remaining screen lines. for (int32 i = destTotalLines; i < destScreenOffset + height; i++) { // Move the line we're going to clear to the history, if that's a // line we've written earlier. TerminalLine* line = screen[i % height]; if (history != NULL && i >= height) history->AddLine(line); line->Clear(fAttributes, width); } // Update the values _FreeLines(fScreen, fHeight); delete fHistory; fScreen = screen; fHistory = history; if (fWidth != width) { status_t error = _ResetTabStops(width); if (error != B_OK) return error; } //debug_printf(" cursor: (%ld, %ld) -> (%ld, %ld)\n", fCursor.x, fCursor.y, //cursor.x, cursor.y); fCursor.x = cursor.x; fCursor.y = cursor.y; fSoftWrappedCursor = false; //debug_printf(" screen offset: %ld -> %ld\n", fScreenOffset, destScreenOffset % height); fScreenOffset = destScreenOffset % height; //debug_printf(" height %ld -> %ld\n", fHeight, height); //debug_printf(" width %ld -> %ld\n", fWidth, width); fHeight = height; fWidth = width; fScrollTop = 0; fScrollBottom = fHeight - 1; fOriginMode = fSavedOriginMode = false; return B_OK; }
void Kinect::KinectHandTracker::getRotatingMove() { // List of hands evidence // If hand matches old positions, previous ID is assigned again const nite::Array<nite::HandData>& hands= this->handTrackerFrame.getHands(); this->slidingHand_x = 0; this->slidingHand_y = 0; this->slidingHand_z = 0; this->slidingHand_type = ""; //strcpy(this->slidingHand_type, ""); for (int i = 0; i < hands.getSize(); ++i) { const nite::HandData& user = hands[i]; if (!user.isTracking()) { //printf("Lost hand %d\n", user.getId()); nite::HandId id = user.getId(); HistoryBuffer<20>* pHistory = this->g_histories[id]; this->g_histories.erase(this->g_histories.find(id)); delete pHistory; } else { if (user.isNew()) { this->g_histories[user.getId()] = new HistoryBuffer<20>; } // Hand evidence in Buffer HistoryBuffer<20>* pHistory = this->g_histories[user.getId()]; pHistory->AddPoint(user.getPosition()); coordinateConverter.convertWorldToDepth(*mDepth, user.getPosition().x, user.getPosition().y, user.getPosition().z, &this->slidingHand_x, &this->slidingHand_y, &this->slidingHand_z); // printf("%lf %lf \n", this->slidingHand_x,this->slidingHand_y ); float koordy[60] = {0}; bool gesto_dolava = false; bool gesto_doprava = false; bool gesto_hore = false; bool gesto_dole = false; if(pHistory->GetSize() == 20) { // ak je historia naplnena const nite::Point3f& position1 = pHistory->operator[](0); this->m_pHandTracker.convertHandCoordinatesToDepth(position1.x, position1.y, position1.z, &koordy[0], &koordy[1]); const nite::Point3f& position2 = pHistory->operator[](19); this->m_pHandTracker.convertHandCoordinatesToDepth(position2.x, position2.y, position2.z, &koordy[2], &koordy[3]); //check for output if(abs(koordy[0] - koordy[2]) > 100.0) { if(koordy[0] > koordy[2]) { gesto_dolava = false; gesto_doprava = true; } else { gesto_dolava = true; gesto_doprava = false; } } if(abs(koordy[1] - koordy[3]) > 100.0) { if(koordy[1] < koordy[3]) { gesto_dole = false; gesto_hore = true; } else { gesto_dole = true; gesto_hore = false; } } if(gesto_dolava) this->slidingHand_type = "scroll left"; else if(gesto_doprava) this->slidingHand_type = "scroll right"; } } } }