void CGame2View::OnMouseMove(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
if (mMouseLbuttonDown)
{
CClientDC dc(this);
if(mBoundingBoxIsUp)
{
// erase our current box...
DrawBoundingBox(mCurSelectRect);
}
// figure new box...
mMouseEndLoc = point;
OnPrepareDC(&dc);
dc.DPtoLP(&mMouseEndLoc);
mCurSelectRect.top = min(mMouseStartLoc.y,mMouseEndLoc.y);
mCurSelectRect.bottom = max(mMouseStartLoc.y,mMouseEndLoc.y);
mCurSelectRect.left = min(mMouseStartLoc.x,mMouseEndLoc.x);
mCurSelectRect.right = max(mMouseStartLoc.x,mMouseEndLoc.x);
// draw the rectangle
mBoundingBoxIsUp = TRUE;
DrawBoundingBox(mCurSelectRect);
}
else
{
CScrollView::OnMouseMove(nFlags, point);
}
}
CursWin::CursWin(int ulr, int ulc, int lrr, int lrc, bool pop) {
if (!numWindows) {
WINDOW* newWin;
newWin = initscr();
cbreak();
refresh();
}
upperLeftRow = ulr;
upperLeftCol = ulc;
lowerRightRow = lrr;
lowerRightCol = lrc;
isPopUp = pop;
if (isPopUp) {
int ySize = (lrr - ulr) + 1, xSize = (lrc - ulc) + 1;
restore = new char*[ySize];
for (int r = 0; r < ySize; r++) {
restore[r] = new char[xSize];
for (int c = 0; c < xSize; c++) {
restore[r][c] = mvinch(ulr+r, ulc+c);
}
}
DrawBoundingBox('#','#','#');
ClearWin();
}
else {
restore = NULL;
DrawBoundingBox('-','|','+');
}
writeEnabled = true;
scrolling = true;
onScreen = true;
curRowPos = curColPos = 0;
headerWidth = footerWidth = 0;
maxRowPos = lowerRightRow - (upperLeftRow+2);
maxColPos = lowerRightCol - (upperLeftCol+2);
sv.expectingStreamParam = false;
sv.precision = 2;
sv.left_justified = true;
sv.last = cflush;
sv.field_enabled = false;
sv.paramNum = 1;
sv.invalid_input = false;
sv.immErrorHandling = false;
sv.min_filter = sv.max_filter = sv.fail_value = 0.0;
sv.force_range = sv.min_active = sv.max_active = false;
sv.filter_active = 0;
CursErrorOut = NULL;
for (int i = 0; i < 1000; i++) {
InputStream[i] = '\0';
}
numWindows++;
}
void CursWin::PlaceWin(int ulr, int ulc, int lrr, int lrc) {
// if (onScreen) EraseWin(true);
upperLeftRow = ulr;
upperLeftCol = ulc;
lowerRightRow = lrr;
lowerRightCol = lrc;
onScreen = true;
writeEnabled = true;
DrawBoundingBox('-','|','+');
ClearWin();
curRowPos = curColPos = 0;
headerWidth = footerWidth = 0;
maxRowPos = lowerRightRow - (upperLeftRow+2);
maxColPos = lowerRightCol - (upperLeftCol+2);
sv.expectingStreamParam = false;
sv.precision = 2;
sv.left_justified = true;
sv.last = cflush;
sv.paramNum = 1;
sv.field_enabled = false;
sv.invalid_input = false;
sv.immErrorHandling = false;
sv.min_filter = sv.max_filter = sv.fail_value = 0.0;
sv.force_range = sv.min_active = sv.max_active = false;
sv.filter_active = 0;
for (int i = 0; i < 1000; i++) {
InputStream[i] = '\0';
}
isPopUp = false;
restore = NULL;
}
// Render - render this model (only)
//-----------------------------------------------------------------------------
void CPUTModelDX11::RenderShadow(CPUTRenderParameters &renderParams)
{
CPUTRenderParametersDX *pParams = (CPUTRenderParametersDX*)&renderParams;
CPUTCamera *pCamera = pParams->mpCamera;
#ifdef SUPPORT_DRAWING_BOUNDING_BOXES
if( renderParams.mShowBoundingBoxes && (!pCamera || pCamera->mFrustum.IsVisible( mBoundingBoxCenterWorldSpace, mBoundingBoxHalfWorldSpace )))
{
DrawBoundingBox( renderParams );
}
#endif
if( !renderParams.mDrawModels ) { return; }
// TODO: add world-space bounding box to model so we don't need to do that work every frame
if( !pParams->mRenderOnlyVisibleModels || !pCamera || pCamera->mFrustum.IsVisible( mBoundingBoxCenterWorldSpace, mBoundingBoxHalfWorldSpace ) )
{
// Update the model's render states only once (and then iterate over materials)
UpdateShaderConstants(renderParams);
CPUTMaterialDX11 *pMaterial = (CPUTMaterialDX11*)(mpShadowCastMaterial);
pMaterial->SetRenderStates(renderParams);
// loop over all meshes in this model and draw them
for(UINT ii=0; ii<mMeshCount; ii++)
{
((CPUTMeshDX11*)mpMesh[ii])->DrawShadow(renderParams, this);
}
}
}
// Render - render this model (only)
//-----------------------------------------------------------------------------
void CPUTModelDX11::Render(CPUTRenderParameters &renderParams)
{
CPUTRenderParametersDX *pParams = (CPUTRenderParametersDX*)&renderParams;
CPUTCamera *pCamera = pParams->mpCamera;
#ifdef SUPPORT_DRAWING_BOUNDING_BOXES
if( renderParams.mShowBoundingBoxes && (!pCamera || pCamera->mFrustum.IsVisible( mBoundingBoxCenterWorldSpace, mBoundingBoxHalfWorldSpace )))
{
DrawBoundingBox( renderParams );
}
#endif
if( !renderParams.mDrawModels ) { return; }
// Update the model's render states only once (and then iterate over materials)
UpdateShaderConstants(renderParams);
bool isVisible = true;
isVisible = !pParams->mRenderOnlyVisibleModels || !pCamera || pCamera->mFrustum.IsVisible( mBoundingBoxCenterWorldSpace, mBoundingBoxHalfWorldSpace );
if( isVisible )
{
// loop over all meshes in this model and draw them
for(UINT ii=0; ii<mMeshCount; ii++)
{
mpMaterial[ii]->SetRenderStates(renderParams);
((CPUTMeshDX11*)mpMesh[ii])->Draw(renderParams, this);
}
}
else
{
mFCullCount++;
}
}
void CGame2View::OnLButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
if (mMouseLbuttonDown)
{
// get client dc for conversion of final rect.
// to logical coord. from device coord.
CClientDC dc(this);
mMouseLbuttonDown = FALSE;
if(mBoundingBoxIsUp)
{
// erase our current box...
DrawBoundingBox(mCurSelectRect);
}
mBoundingBoxIsUp = FALSE;
// figure new box...
mMouseEndLoc = point;
OnPrepareDC(&dc);
dc.DPtoLP(&mMouseEndLoc);
mCurSelectRect.top = min(mMouseStartLoc.y,mMouseEndLoc.y);
mCurSelectRect.bottom = max(mMouseStartLoc.y,mMouseEndLoc.y);
mCurSelectRect.left = min(mMouseStartLoc.x,mMouseEndLoc.x);
mCurSelectRect.right = max(mMouseStartLoc.x,mMouseEndLoc.x);
if( ((mCurSelectRect.bottom - mCurSelectRect.top) < MIN_BOX_WIDTH)
&& ((mCurSelectRect.right - mCurSelectRect.left) < MIN_BOX_WIDTH) )
{
mPointSelectMode = TRUE;
mCurSelectPoint = mMouseEndLoc;
// dc.DPtoLP(&mCurSelectPoint);
}
else
{
mPointSelectMode = FALSE;
// dc.DPtoLP(&mCurSelectRect);
}
// do something here (we now have our selection rectangle
// convert to logical coordinates from device..
// show proper stuff as selected..
ProcessSelected();
// force a redraw
Invalidate(FALSE);
// GetDocument()->UpdateAllViews(this);
}
else
{
CScrollView::OnLButtonUp(nFlags, point);
}
}
void RPG_Trigger::ThinkFunction()
{
if(!Vision::Editor.IsInEditor() && m_displayDebug)
{
// draw the bounding box if we aren't in the editor but want to draw debug info.
DrawBoundingBox(TRUE, m_boundsDisplayColor, m_boundsDisplayLineWidth);
}
const float deltaTime = Vision::GetTimer()->GetTimeDifference();
// TODO - implement both server and client tick
ServerTick(deltaTime);
}
void GRSingleRest::OnDraw( VGDevice & hdc ) const
{
traceMethod("OnDraw");
if (mType == P0) return; // don't know how to draw it !
GRRest::OnDrawSymbol( hdc, mType );
DrawSubElements( hdc ); // - Draw elements (dots...)
// Draw articulations (fermata...)
const GRNEList * articulations = getArticulations();
if( articulations ) {
for( GRNEList::const_iterator ptr = articulations->begin(); ptr != articulations->end(); ++ptr )
{
GRNotationElement * el = *ptr;
el->OnDraw(hdc);
}
}
if (gBoundingBoxesMap & kEventsBB)
DrawBoundingBox( hdc, kEventBBColor);
}
CursWin::CursWin(int ulr, int ulc, int lrr, int lrc, char rowC, char colC, char cornerC) {
if (!numWindows) {
WINDOW* newWin;
newWin = initscr();
cbreak();
refresh();
}
upperLeftRow = ulr;
upperLeftCol = ulc;
lowerRightRow = lrr;
lowerRightCol = lrc;
DrawBoundingBox(rowC, colC, cornerC);
writeEnabled = true;
scrolling = true;
onScreen = true;
curRowPos = curColPos = 0;
headerWidth = footerWidth = 0;
maxRowPos = lowerRightRow - (upperLeftRow+2);
maxColPos = lowerRightCol - (upperLeftCol+2);
sv.expectingStreamParam = false;
sv.precision = 2;
sv.left_justified = true;
sv.last = cflush;
sv.field_enabled = false;
sv.paramNum = 1;
sv.invalid_input = false;
sv.immErrorHandling = false;
sv.min_filter = sv.max_filter = sv.fail_value = 0.0;
sv.force_range = sv.min_active = sv.max_active = false;
sv.filter_active = 0;
CursErrorOut = NULL;
for (int i = 0; i < 1000; i++) {
InputStream[i] = '\0';
}
isPopUp = false;
restore = NULL;
numWindows++;
}
// Render this model. Render only this model, not its children or siblings.
//-----------------------------------------------------------------------------
void CPUTModelDX11::Render(CPUTRenderParameters &renderParams, int materialIndex)
{
CPUTRenderParametersDX *pParams = (CPUTRenderParametersDX*)&renderParams;
CPUTCamera *pCamera = pParams->mpCamera;
// TODO: Move bboxDirty to member and set only when model moves.
bool bboxDirty = true;
if( bboxDirty )
{
UpdateBoundsWorldSpace();
}
#ifdef SUPPORT_DRAWING_BOUNDING_BOXES
if( renderParams.mShowBoundingBoxes && (!pCamera || pCamera->mFrustum.IsVisible( mBoundingBoxCenterWorldSpace, mBoundingBoxHalfWorldSpace )))
{
DrawBoundingBox( renderParams );
}
#endif
if( !renderParams.mDrawModels ) { return; }
if( !pParams->mRenderOnlyVisibleModels || !pCamera || pCamera->mFrustum.IsVisible( mBoundingBoxCenterWorldSpace, mBoundingBoxHalfWorldSpace ) )
{
// Update the model's constant buffer.
// Note that the materials reference this, so we need to do it only once for all of the model's meshes.
UpdateShaderConstants(renderParams);
// loop over all meshes in this model and draw them
for(UINT ii=0; ii<mMeshCount; ii++)
{
UINT finalMaterialIndex = GetMaterialIndex(ii, materialIndex);
ASSERT( finalMaterialIndex < mpSubMaterialCount[ii], _L("material index out of range."));
CPUTMaterialDX11 *pMaterial = (CPUTMaterialDX11*)(mpMaterial[ii][finalMaterialIndex]);
pMaterial->SetRenderStates(renderParams);
((CPUTMeshDX11*)mpMesh[ii])->Draw(renderParams, mpInputLayout[ii][finalMaterialIndex]);
}
}
}
void SampleViewer::Display()
{
nite::UserTrackerFrameRef userTrackerFrame;
openni::VideoFrameRef depthFrame;
nite::Status rc = m_pUserTracker->readFrame(&userTrackerFrame);
if (rc != nite::STATUS_OK)
{
printf("GetNextData failed\n");
return;
}
depthFrame = userTrackerFrame.getDepthFrame();
m_colorStream.readFrame(&m_colorFrame);
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];
}
const nite::UserMap& userLabels = userTrackerFrame.getUserMap();
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, GL_WIN_SIZE_X, GL_WIN_SIZE_Y, 0, -2000.0, 2000.0);
if (depthFrame.isValid() && g_drawDepth)
{
calculateHistogram(m_pDepthHist, MAX_DEPTH, depthFrame);
}
memset(m_pTexMap, 0, m_nTexMapX*m_nTexMapY*sizeof(openni::RGB888Pixel));
// check if we need to draw image frame to texture
if (m_eViewState == DISPLAY_MODE_IMAGE && m_colorFrame.isValid())
{
const openni::RGB888Pixel* pImageRow = (const openni::RGB888Pixel*)m_colorFrame.getData();
openni::RGB888Pixel* pTexRow = m_pTexMap + m_colorFrame.getCropOriginY() * m_nTexMapX;
int rowSize = m_colorFrame.getStrideInBytes() / sizeof(openni::RGB888Pixel);
for (int y = 0; y < m_colorFrame.getHeight(); ++y)
{
const openni::RGB888Pixel* pImage = pImageRow;
openni::RGB888Pixel* pTex = pTexRow + m_colorFrame.getCropOriginX();
for (int x = 0; x < m_colorFrame.getWidth(); ++x, ++pImage, ++pTex)
{
*pTex = *pImage;
}
pImageRow += rowSize;
pTexRow += m_nTexMapX;
}
}
float factor[3] = {1, 1, 1};
// check if we need to draw depth frame to texture
if (depthFrame.isValid() && g_drawDepth)
{
const nite::UserId* pLabels = userLabels.getPixels();
const openni::DepthPixel* pDepthRow = (const openni::DepthPixel*)depthFrame.getData();
openni::RGB888Pixel* pTexRow = m_pTexMap + depthFrame.getCropOriginY() * m_nTexMapX;
int rowSize = depthFrame.getStrideInBytes() / sizeof(openni::DepthPixel);
for (int y = 0; y < depthFrame.getHeight(); ++y)
{
const openni::DepthPixel* pDepth = pDepthRow;
openni::RGB888Pixel* pTex = pTexRow + depthFrame.getCropOriginX();
for (int x = 0; x < depthFrame.getWidth(); ++x, ++pDepth, ++pTex, ++pLabels)
{
if (*pDepth != 0)
{
if (*pLabels == 0)
{
if (!g_drawBackground)
{
factor[0] = factor[1] = factor[2] = 0;
}
else
{
factor[0] = Colors[colorCount][0];
factor[1] = Colors[colorCount][1];
factor[2] = Colors[colorCount][2];
}
}
else
{
factor[0] = Colors[*pLabels % colorCount][0];
factor[1] = Colors[*pLabels % colorCount][1];
factor[2] = Colors[*pLabels % colorCount][2];
}
// // Add debug lines - every 10cm
// else if ((*pDepth / 10) % 10 == 0)
// {
// factor[0] = factor[2] = 0;
// }
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;
}
}
pDepthRow += rowSize;
pTexRow += m_nTexMapX;
}
}
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_nTexMapX, m_nTexMapY, 0, GL_RGB, GL_UNSIGNED_BYTE, m_pTexMap);
// Display the OpenGL texture map
glColor4f(1,1,1,1);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
g_nXRes = depthFrame.getVideoMode().getResolutionX();
g_nYRes = depthFrame.getVideoMode().getResolutionY();
// upper left
glTexCoord2f(0, 0);
glVertex2f(0, 0);
// upper right
glTexCoord2f((float)g_nXRes/(float)m_nTexMapX, 0);
glVertex2f(GL_WIN_SIZE_X, 0);
// bottom right
glTexCoord2f((float)g_nXRes/(float)m_nTexMapX, (float)g_nYRes/(float)m_nTexMapY);
glVertex2f(GL_WIN_SIZE_X, GL_WIN_SIZE_Y);
// bottom left
glTexCoord2f(0, (float)g_nYRes/(float)m_nTexMapY);
glVertex2f(0, GL_WIN_SIZE_Y);
glEnd();
glDisable(GL_TEXTURE_2D);
const nite::Array<nite::UserData>& users = userTrackerFrame.getUsers();
for (int i = 0; i < users.getSize(); ++i)
{
const nite::UserData& user = users[i];
updateUserState(user, userTrackerFrame.getTimestamp());
if (user.isNew())
{
m_pUserTracker->startSkeletonTracking(user.getId());
m_pUserTracker->startPoseDetection(user.getId(), nite::POSE_CROSSED_HANDS);
}
else if (!user.isLost())
{
if (g_drawStatusLabel)
{
DrawStatusLabel(m_pUserTracker, user);
}
if (g_drawCenterOfMass)
{
DrawCenterOfMass(m_pUserTracker, user);
}
if (g_drawBoundingBox)
{
DrawBoundingBox(user);
}
if (users[i].getSkeleton().getState() == nite::SKELETON_TRACKED && g_drawSkeleton)
{
DrawSkeleton(m_pUserTracker, user);
}
if (users[i].getSkeleton().getState() == nite::SKELETON_TRACKED && g_drawHat)
{
DrawHat(m_pUserTracker, user);
}
if (users[i].getSkeleton().getState() == nite::SKELETON_TRACKED && g_drawCube)
{
DrawCube(m_pUserTracker, user);
}
if (users[i].getSkeleton().getState() == nite::SKELETON_TRACKED && g_drawCubeFront)
{
DrawCubeFront(m_pUserTracker, user);
}
}
if (m_poseUser == 0 || m_poseUser == user.getId())
{
const nite::PoseData& pose = user.getPose(nite::POSE_CROSSED_HANDS);
if (pose.isEntered())
{
// Start timer
sprintf(g_generalMessage, "In exit pose. Keep it for %d second%s to exit\n", g_poseTimeoutToExit/1000, g_poseTimeoutToExit/1000 == 1 ? "" : "s");
printf("Counting down %d second to exit\n", g_poseTimeoutToExit/1000);
m_poseUser = user.getId();
m_poseTime = userTrackerFrame.getTimestamp();
}
else if (pose.isExited())
{
memset(g_generalMessage, 0, sizeof(g_generalMessage));
printf("Count-down interrupted\n");
m_poseTime = 0;
m_poseUser = 0;
}
else if (pose.isHeld())
{
// tick
if (userTrackerFrame.getTimestamp() - m_poseTime > g_poseTimeoutToExit * 1000)
{
printf("Count down complete. Exit...\n");
Finalize();
exit(2);
}
}
}
}
if (g_drawFrameId)
{
DrawFrameId(userTrackerFrame.getFrameIndex());
}
if (g_generalMessage[0] != '\0')
{
char *msg = g_generalMessage;
glColor3f(1.0f, 0.0f, 0.0f);
glRasterPos2i(100, 20);
glPrintString(GLUT_BITMAP_HELVETICA_18, msg);
}
// Swap the OpenGL display buffers
glutSwapBuffers();
}
int main(int argc, char * argv[])
{
system("bash dataprep.sh");
#pragma omp parallel for
for(int n=1; n<argc; n++)
{
Mat srcImg=imread(argv[n],CV_LOAD_IMAGE_GRAYSCALE);
Mat img=imread(argv[n],CV_LOAD_IMAGE_COLOR);
string str=argv[n];
cout<<"\n\n processing the image: "<<str<<endl;
if (!srcImg.data)
{
cout<<"failed to load the image!\n";
// return 0;
continue;
}
for(int i=0; i< srcImg.rows; i++)
{
for(int j=0; j<5; j++)
{
srcImg.at<uchar>(i,j)=uchar(0);
srcImg.at<uchar>(i,srcImg.cols-j-1)=uchar(0);
}
}
for(int i=0; i<srcImg.cols; i++)
{
for(int j=0; j<5; j++)
{
srcImg.at<uchar>(j,i)=uchar(0);
srcImg.at<uchar>(srcImg.rows-j-1,i)=uchar(0);
}
}
//detect lsd lines in an input image;
int cols=srcImg.rows;
int rows=srcImg.cols;
double* lsd_srcImg=new double[cols*rows];
for (int i=0; i<cols; i++)
{
for (int j=0; j<rows; j++)
{
lsd_srcImg[i+j*cols]=static_cast<double>(srcImg.at<uchar>(i,j));
}
}
double* lsd_dstImg;
int n=0;
lsd_dstImg=lsd(&n,lsd_srcImg,cols,rows);
cout<<"finished the lsd detection!\n";
vector<LSDline> lsdLine;
for (int i=0; i<n; i++)
{
LSDline lsdLine_tmp;
lsdLine_tmp.lineBegin.y=lsd_dstImg[i*7+0];
lsdLine_tmp.lineBegin.x=lsd_dstImg[i*7+1];
lsdLine_tmp.lineEnd.y=lsd_dstImg[i*7+2];
lsdLine_tmp.lineEnd.x=lsd_dstImg[i*7+3];
lsdLine_tmp.width=lsd_dstImg[i*7+4];
lsdLine_tmp.p=lsd_dstImg[i*7+5];
lsdLine_tmp.log_nfa=lsd_dstImg[i*7+6];
lsdLine_tmp.tagBegin=1;
lsdLine_tmp.tagEnd=1;
cout<<lsdLine_tmp.lineBegin.x<<" "<<lsdLine_tmp.lineBegin.y<<" "<<lsdLine_tmp.lineEnd.x<<" "<<lsdLine_tmp.lineEnd.y<<endl;
float distThreshold=12;
if(sqrt((lsdLine_tmp.lineBegin.x-lsdLine_tmp.lineEnd.x)*(lsdLine_tmp.lineBegin.x-lsdLine_tmp.lineEnd.x)+
(lsdLine_tmp.lineBegin.y-lsdLine_tmp.lineEnd.y)*(lsdLine_tmp.lineBegin.y-lsdLine_tmp.lineEnd.y))>distThreshold)
{
lsdLine.push_back(lsdLine_tmp);
}
}
cout<<"the detected lsd lines' number is: "<<lsdLine.size()<<endl;
//define the img1 to display the detected LSD lines and junctions;
Mat img1(img.size(),CV_8UC3,Scalar::all(0));
delete[] lsd_srcImg;
displayLSDline(lsdLine,img1);
//imwrite("img1.bmp",img1);
vector<Ljunct> Jlist;
vector<LsdJunction> lsdJunction;
if(LSD2Junct(lsdLine,Jlist,lsdJunction,search_distance,img))
{
cout<<"transform successfully!\n";
}
else
{
cout<<"cannot form L-junctions from LSD lines!\n";
//for processing, we also need to write the the detect result;
char c='_';
int name_end=str.find(c,0);
string ori_name_tmp1=str.substr(7,name_end-7);
// char* ch2=".bmp";
// int location=str.find(ch2,0);
// string ori_name_tmp1 = str.substr(7,location-7);
string dst_tmp = "./DetectResultOri/"+ori_name_tmp1;
string ori_name_tmp="./OrigImg/"+ori_name_tmp1;
// Mat oriImg_tmp = imread(ori_name_tmp.c_str(),CV_LOAD_IMAGE_COLOR);
// imwrite(dst_tmp,oriImg_tmp);
string filestring_tmp="./dstFile/"+str.substr(srcImgDir.size(),str.size()-4)+".jpg.txt";
ofstream file_out(filestring_tmp.c_str());
if(!file_out.is_open())
{
cout<<"cannot open the txt file!\n";
}
string imageName=str.substr(srcImgDir.size(),str.size()-4)+".jpg";
file_out<<imageName<<"\t"<<img.cols<<"\t"<<img.rows<<endl;
continue;
}
//vector<string> code_string1;
vector<Ljunct> Jlist_coding;
vector<codeStringBoundingBox> code_string;
code_string=encodingFromLsdJunction(lsdJunction, Jlist_coding,srcImg);
classifyRoadMarking(code_string,srcImg);
string str_tmp=str.substr(srcImgDir.size(),str.size());
cout<<"!!!!!the Jlist_coding size is: "<<Jlist_coding.size()<<endl<<endl;
displayLjunct(Jlist_coding,img1,str_tmp);
DrawBoundingBox(code_string,img,str_tmp);
//drawing the bounding box in original image;
char c='_';
int name_end=str.find(c,0);
// string ori_name=str.substr(7,name_end-7);
char* ch=".bmp";
int location=str.find(ch,0);
cout<<"the find .bmp in "<<str<<" is in "<<location<<endl;
string ori_name=str.substr(7,location-7);
cout<<ori_name<<endl;
string ori_img="./OrigImg/"+ori_name+".JPG";
Mat oriImg=imread(ori_img.c_str(),CV_LOAD_IMAGE_COLOR);
if(!oriImg.data)
{
cout<<"cannot load the original image!\n";
//return 0;
char ch;
cin.get(ch);
continue;
}
/*
Point2f imgP1=Point2f(219,668);
Point2f imgP2=Point2f(452,469);
Point2f imgP3=Point2f(622,472);
Point2f imgP4=Point2f(882,681);
Point2f imgP5=Point2f(388,520);
Point2f imgP6=Point2f(688,523);
Point2f imgP7=Point2f(454,538);
Point2f imgP8=Point2f(645,539);
Point2f imgP9=Point2f(508,486);
Point2f imgP10=Point2f(573,509);
Point2f imgP[10]= {imgP1,imgP2,imgP3,imgP4,imgP5,imgP6,imgP7,imgP8,imgP9,imgP10};
Point2f objP1=Point2f(250,900);
Point2f objP2=Point2f(250,100);
Point2f objP3=Point2f(800,100);
Point2f objP4=Point2f(800,900);
Point2f objP5=Point2f(250,550);
Point2f objP6=Point2f(800,550);
Point2f objP7=Point2f(400,625);
Point2f objP8=Point2f(650,625);
Point2f objP9=Point2f(450,300);
Point2f objP10=Point2f(600,475);
Point2f objP[10]= {objP1,objP2,objP3,objP4,objP5,objP6,objP7,objP8,objP9,objP10};
*/
vector<Point2f> imgP;
imgP.push_back(Point2f(300,450));
imgP.push_back(Point2f(700,450));
imgP.push_back(Point2f(465,450));
imgP.push_back(Point2f(535,450));
imgP.push_back(Point2f(260,820));
imgP.push_back(Point2f(740,820));
vector<Point2f> objP;
objP.push_back(Point2f(0,0));
objP.push_back(Point2f(1000,0));
objP.push_back(Point2f(400,0));
objP.push_back(Point2f(600,0));
objP.push_back(Point2f(400,1000));
objP.push_back(Point2f(600,1000));
//Mat H=getPerspectiveTransform(objP,imgP);
Mat H=findHomography(objP,imgP,CV_RANSAC);
DrawBoundingBox_Ori(code_string,oriImg,ori_name,H,str_tmp);
}
return 0;
}
void CGame2View::OnDraw(CDC* pDC)
{
int result;
CRect ClientRect;
CRect MapSectionRect;
CGame2Doc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// TODO: add draw code for native data here
GameMapObserver *GameMap = pDoc->GetMap();
Unit *theUnit;
int max_x = pDoc->GetMapWidth();
int max_y = pDoc->GetMapHeight();
int x,y;
// clear the memory DC
mInMemoryScreenDC.FillSolidRect(mMapRect,RGB(255,255,255));
// Draw box around map...
mInMemoryScreenDC.MoveTo(0 ,0 );
mInMemoryScreenDC.LineTo(mMapRect.right - 1 ,0 );
mInMemoryScreenDC.LineTo(mMapRect.right - 1 ,mMapRect.bottom - 1);
mInMemoryScreenDC.LineTo(0 ,mMapRect.bottom - 1);
mInMemoryScreenDC.LineTo(0 ,0 );
// Draw into it
for (x = 0; x < max_x; x++)
{
for(y = 0; y < max_y; y++)
{
if( (theUnit = GameMap->RequestLoc(x,y)))
{
theUnit->DrawUnit(&mInMemoryScreenDC);
}
}
}
if(mBoundingBoxIsUp)
{
DrawBoundingBox(mCurSelectRect);
}
mFlasher +=20;
if(mFlasher>200)
mFlasher = 0;
mInMemoryScreenDC.FillSolidRect( 60 + mFlasher,
10,
10,
10,
RGB(0,0,0));
GetClientRect(&ClientRect);
MapSectionRect = ClientRect;
// OnPrepareDC();
pDC->DPtoLP(&MapSectionRect);
// Blt it to screen
result = pDC->BitBlt(MapSectionRect.left,
MapSectionRect.top,
ClientRect.right,
ClientRect.bottom,
&mInMemoryScreenDC,
MapSectionRect.left,
MapSectionRect.top,
SRCCOPY);
}
void SampleViewer::Display()
{
// namespace bg = boost::geometry;
nite::UserTrackerFrameRef userTrackerFrame;
openni::VideoFrameRef depthFrame;
nite::Status rc = m_pUserTracker->readFrame(&userTrackerFrame);
if (rc != nite::STATUS_OK)
{
printf("GetNextData failed\n");
return;
}
depthFrame = userTrackerFrame.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];
}
const nite::UserMap& userLabels = userTrackerFrame.getUserMap();
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, GL_WIN_SIZE_X, GL_WIN_SIZE_Y, 0, -1.0, 1.0);
if (depthFrame.isValid() && g_drawDepth)
{
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
if (depthFrame.isValid() && g_drawDepth)
{
const nite::UserId* pLabels = userLabels.getPixels();
const openni::DepthPixel* pDepthRow = (const openni::DepthPixel*)depthFrame.getData();
openni::RGB888Pixel* pTexRow = m_pTexMap + depthFrame.getCropOriginY() * m_nTexMapX;
int rowSize = depthFrame.getStrideInBytes() / sizeof(openni::DepthPixel);
for (int y = 0; y < depthFrame.getHeight(); ++y)
{
const openni::DepthPixel* pDepth = pDepthRow;
openni::RGB888Pixel* pTex = pTexRow + depthFrame.getCropOriginX();
for (int x = 0; x < depthFrame.getWidth(); ++x, ++pDepth, ++pTex, ++pLabels)
{
if (*pDepth != 0)
{
if (*pLabels == 0)
{
if (!g_drawBackground)
{
factor[0] = factor[1] = factor[2] = 0;
}
else
{
factor[0] = Colors[colorCount][0];
factor[1] = Colors[colorCount][1];
factor[2] = Colors[colorCount][2];
}
}
else
{
factor[0] = Colors[*pLabels % colorCount][0];
factor[1] = Colors[*pLabels % colorCount][1];
factor[2] = Colors[*pLabels % colorCount][2];
}
// // Add debug lines - every 10cm
// else if ((*pDepth / 10) % 10 == 0)
// {
// factor[0] = factor[2] = 0;
// }
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;
}
}
pDepthRow += rowSize;
pTexRow += m_nTexMapX;
}
}
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_nTexMapX, m_nTexMapY, 0, GL_RGB, GL_UNSIGNED_BYTE, m_pTexMap);
// Display the OpenGL texture map
glColor4f(1,1,1,1);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
g_nXRes = depthFrame.getVideoMode().getResolutionX();
g_nYRes = depthFrame.getVideoMode().getResolutionY();
// upper left
glTexCoord2f(0, 0);
glVertex2f(0, 0);
// upper right
glTexCoord2f((float)g_nXRes/(float)m_nTexMapX, 0);
glVertex2f(GL_WIN_SIZE_X, 0);
// bottom right
glTexCoord2f((float)g_nXRes/(float)m_nTexMapX, (float)g_nYRes/(float)m_nTexMapY);
glVertex2f(GL_WIN_SIZE_X, GL_WIN_SIZE_Y);
// bottom left
glTexCoord2f(0, (float)g_nYRes/(float)m_nTexMapY);
glVertex2f(0, GL_WIN_SIZE_Y);
glEnd();
glDisable(GL_TEXTURE_2D);
const nite::Array<nite::UserData>& users = userTrackerFrame.getUsers();
// 11.16.15 remove for loop for tracking only one user
// for (int i = 0; i < users.getSize(); ++i)
// {
//const nite::UserData& user = users[i];
if (users.getSize() > 0) {
const nite::UserData& user = users[0];
updateUserState(user, userTrackerFrame.getTimestamp());
if (user.isNew())
{
m_pUserTracker->startSkeletonTracking(user.getId());
m_pUserTracker->startPoseDetection(user.getId(), nite::POSE_CROSSED_HANDS);
}
else if (!user.isLost())
{
if (g_drawStatusLabel)
{
DrawStatusLabel(m_pUserTracker, user);
}
if (g_drawCenterOfMass)
{
DrawCenterOfMass(m_pUserTracker, user);
}
if (g_drawBoundingBox)
{
DrawBoundingBox(user);
}
if (user.getSkeleton().getState() == nite::SKELETON_TRACKED && g_drawSkeleton)
{
DrawSkeleton(m_pUserTracker, user);
}
}
if (m_poseUser == 0 || m_poseUser == user.getId())
{
const nite::PoseData& pose = user.getPose(nite::POSE_CROSSED_HANDS);
if (pose.isEntered())
{
// Start timer
sprintf(g_generalMessage, "In exit pose. Keep it for %d second%s to exit\n", g_poseTimeoutToExit/1000, g_poseTimeoutToExit/1000 == 1 ? "" : "s");
printf("Counting down %d second to exit\n", g_poseTimeoutToExit/1000);
m_poseUser = user.getId();
m_poseTime = userTrackerFrame.getTimestamp();
}
else if (pose.isExited())
{
memset(g_generalMessage, 0, sizeof(g_generalMessage));
printf("Count-down interrupted\n");
m_poseTime = 0;
m_poseUser = 0;
}
else if (pose.isHeld())
{
// tick
if (userTrackerFrame.getTimestamp() - m_poseTime > g_poseTimeoutToExit * 1000)
{
printf("Count down complete. Exit...\n");
Finalize();
exit(2);
}
}
} //user
char buffer[80] = "";
// ---------------- calculate right shoulder 2 DOF ----------------------
int rightShoulderX, rightShoulderY, rightShoulderZ;
rightShoulderX = user.getSkeleton().getJoint(nite::JOINT_RIGHT_ELBOW).getPosition().x -
user.getSkeleton().getJoint(nite::JOINT_RIGHT_SHOULDER).getPosition().x;
rightShoulderY = user.getSkeleton().getJoint(nite::JOINT_RIGHT_ELBOW).getPosition().y -
user.getSkeleton().getJoint(nite::JOINT_RIGHT_SHOULDER).getPosition().y;
rightShoulderZ = user.getSkeleton().getJoint(nite::JOINT_RIGHT_ELBOW).getPosition().z -
user.getSkeleton().getJoint(nite::JOINT_RIGHT_SHOULDER).getPosition().z;
Spherical rightShoulderSpherical;
rightShoulderSpherical = Cartesian2Spherical(rightShoulderX, rightShoulderY, rightShoulderZ);
int rightShoulderPhi, rightShoulderTheta;
rightShoulderTheta = radian2Degree(rightShoulderSpherical.radianTheta, rightShoulderThetaInit); // horizontal rise it's -60 degree
rightShoulderPhi = radian2Degree(rightShoulderSpherical.radianPhi, rightShoulderPitchInit); // when hand's down, it's 70 degree
int rightShoulderYawNow = rightShoulderPhi * sin(rightShoulderTheta * PI / 180);
int rightShoulderPitchNow = rightShoulderPhi * cos(rightShoulderTheta * PI / 180);
sprintf(buffer,"(rightShoulderTheta=%d, rightShoulderYaw=%d, rightShoulderPitch=%d)", rightShoulderTheta, rightShoulderYawNow, rightShoulderPitchNow);
glColor3f(1.0f, 0.0f, 0.0f);
glRasterPos2i(20, 20);
glPrintString(GLUT_BITMAP_HELVETICA_18, buffer);
// ------------------- calculate right elbow 2 DOF -----------------------
int rightElbowX, rightElbowY, rightElbowZ;
rightElbowX = user.getSkeleton().getJoint(nite::JOINT_RIGHT_HAND).getPosition().x -
user.getSkeleton().getJoint(nite::JOINT_RIGHT_ELBOW).getPosition().x;
rightElbowY = user.getSkeleton().getJoint(nite::JOINT_RIGHT_HAND).getPosition().y -
user.getSkeleton().getJoint(nite::JOINT_RIGHT_ELBOW).getPosition().y;
rightElbowZ = user.getSkeleton().getJoint(nite::JOINT_RIGHT_HAND).getPosition().z -
user.getSkeleton().getJoint(nite::JOINT_RIGHT_ELBOW).getPosition().z;
Spherical rightElbowSpherical;
rightElbowSpherical = Cartesian2Spherical(rightElbowX, rightElbowY, rightElbowZ);
int rightElbowThetaNow = - radian2Degree(rightElbowSpherical.radianTheta, rightElbowThetaInit); // reverse for system
int rightElbowYawNow = radian2Degree(rightElbowSpherical.radianPhi, rightElbowYawInit);
sprintf(buffer,"(rightElbowThetaNow=%d, rightElbowYawNow=%d)", rightElbowThetaNow, rightElbowYawNow);
glColor3f(1.0f, 0.0f, 0.0f);
glRasterPos2i(20, 60);
glPrintString(GLUT_BITMAP_HELVETICA_18, buffer);
// ---------------- calculate left shoulder 2 DOF ----------------------
int leftShoulderX, leftShoulderY, leftShoulderZ;
leftShoulderX = user.getSkeleton().getJoint(nite::JOINT_LEFT_ELBOW).getPosition().x -
user.getSkeleton().getJoint(nite::JOINT_LEFT_SHOULDER).getPosition().x;
leftShoulderY = user.getSkeleton().getJoint(nite::JOINT_LEFT_ELBOW).getPosition().y -
user.getSkeleton().getJoint(nite::JOINT_LEFT_SHOULDER).getPosition().y;
leftShoulderZ = user.getSkeleton().getJoint(nite::JOINT_LEFT_ELBOW).getPosition().z -
user.getSkeleton().getJoint(nite::JOINT_LEFT_SHOULDER).getPosition().z;
Spherical leftShoulderSpherical;
leftShoulderSpherical = Cartesian2Spherical(leftShoulderX, leftShoulderY, leftShoulderZ);
int leftShoulderPhi, leftShoulderTheta;
leftShoulderTheta = radian2Degree(leftShoulderSpherical.radianTheta, leftShoulderThetaInit); // horizontal rise it's -60 degree
leftShoulderPhi = radian2Degree(leftShoulderSpherical.radianPhi, leftShoulderPitchInit); // when hand's down, it's 70 degree
// need to reverse in left side
int leftShoulderYawNow = - leftShoulderPhi * sin(leftShoulderTheta * PI / 180);
int leftShoulderPitchNow = - leftShoulderPhi * cos(leftShoulderTheta * PI / 180);
sprintf(buffer,"(leftShoulderTheta=%d, leftShoulderYaw=%d, leftShoulderPitch=%d)", leftShoulderTheta, leftShoulderYawNow, leftShoulderPitchNow);
glColor3f(1.0f, 0.0f, 0.0f);
glRasterPos2i(20, 100);
glPrintString(GLUT_BITMAP_HELVETICA_18, buffer);
// ------------------- calculate left elbow 2 DOF -----------------------
int leftElbowX, leftElbowY, leftElbowZ;
leftElbowX = user.getSkeleton().getJoint(nite::JOINT_LEFT_HAND).getPosition().x -
user.getSkeleton().getJoint(nite::JOINT_LEFT_ELBOW).getPosition().x;
leftElbowY = user.getSkeleton().getJoint(nite::JOINT_LEFT_HAND).getPosition().y -
user.getSkeleton().getJoint(nite::JOINT_LEFT_ELBOW).getPosition().y;
leftElbowZ = user.getSkeleton().getJoint(nite::JOINT_LEFT_HAND).getPosition().z -
user.getSkeleton().getJoint(nite::JOINT_LEFT_ELBOW).getPosition().z;
Spherical leftElbowSpherical;
leftElbowSpherical = Cartesian2Spherical(leftElbowX, leftElbowY, leftElbowZ);
int leftElbowThetaNow = radian2Degree(leftElbowSpherical.radianTheta, leftElbowThetaInit);
int leftElbowYawNow = radian2Degree(leftElbowSpherical.radianPhi, leftElbowYawInit);
sprintf(buffer,"(leftElbowTheta=%d, leftElbowYawNow=%d)", leftElbowThetaNow, leftElbowYawNow);
glColor3f(1.0f, 0.0f, 0.0f);
glRasterPos2i(20, 140);
glPrintString(GLUT_BITMAP_HELVETICA_18, buffer);
// ---------------- constraint movement and publish message ------------
int rightShoulderYawDiff = abs(rightShoulderYaw - rightShoulderYawNow);
int rightShoulderPitchDiff = abs(rightShoulderPitch - rightShoulderPitchNow);
int rightElbowThetaDiff = abs(rightElbowTheta - rightElbowThetaNow);
int rightElbowYawDiff = abs(rightElbowYaw - rightElbowYawNow);
int leftShoulderYawDiff = abs(leftShoulderYaw - leftShoulderYawNow);
int leftShoulderPitchDiff = abs(leftShoulderPitch - leftShoulderPitchNow);
int leftElbowThetaDiff = abs(leftElbowTheta - leftElbowThetaNow);
int leftElbowYawDiff = abs(leftElbowYaw - leftElbowYawNow);
if ((rightShoulderYawDiff < moveLimitDegree) && (rightShoulderPitchDiff < moveLimitDegree) && (rightElbowThetaDiff < moveLimitDegree) && (rightElbowYawDiff < moveLimitDegree) && (rightShoulderTheta >= 0)) {
// in range then refresh robot angle
rightShoulderYaw = rightShoulderYawNow;
rightShoulderPitch = rightShoulderPitchNow;
rightElbowTheta = rightElbowThetaNow;
rightElbowYaw = rightElbowYawNow;
// change the angle to 0 to 360 and publish
rightShoulderYawPub = angleHandler(rightShoulderYaw);
rightShoulderPitchPub = angleHandler(rightShoulderPitch);
rightElbowThetaPub = angleHandler(rightElbowTheta);
rightElbowYawPub = angleHandler(rightElbowYaw);
sprintf(buffer,"tracking!");
glColor3f(0.0f, 0.0f, 1.0f);
glRasterPos2i(20, 180);
glPrintString(GLUT_BITMAP_HELVETICA_18, buffer);
actionPublish(rightShoulderYawPub, rightShoulderPitchPub, rightElbowThetaPub, rightElbowYawPub, leftShoulderYawPub, leftShoulderPitchPub, leftElbowThetaPub, leftElbowYawPub);
}
else {
sprintf(buffer,"soulder yaw: %d, soulder pitch: %d, elbow yaw: %d, rightShoulderTheta > 0: %d", rightShoulderYaw - rightShoulderYawNow, rightShoulderPitch - rightShoulderPitchNow, rightElbowYaw - rightElbowYawNow, rightShoulderTheta);
glColor3f(1.0f, 0.0f, 0.5f);
glRasterPos2i(20, 180);
glPrintString(GLUT_BITMAP_HELVETICA_18, buffer);
}
if((leftShoulderYawDiff < moveLimitDegree) && (leftShoulderPitchDiff < moveLimitDegree) && (leftElbowThetaDiff < moveLimitDegree) && (leftElbowYawDiff < moveLimitDegree) && (leftShoulderTheta >= 0)) {
leftShoulderYaw = leftShoulderYawNow;
leftShoulderPitch = leftShoulderPitchNow;
leftElbowTheta = leftElbowThetaNow;
leftElbowYaw = leftElbowYawNow;
leftShoulderYawPub = angleHandler(leftShoulderYaw);
leftShoulderPitchPub = angleHandler(leftShoulderPitch);
leftElbowThetaPub = angleHandler(leftElbowTheta);
leftElbowYawPub = angleHandler(leftElbowYaw);
sprintf(buffer,"tracking!");
glColor3f(0.0f, 0.3f, 1.0f);
glRasterPos2i(20, 220);
glPrintString(GLUT_BITMAP_HELVETICA_18, buffer);
actionPublish(rightShoulderYawPub, rightShoulderPitchPub, rightElbowThetaPub, rightElbowYawPub, leftShoulderYawPub, leftShoulderPitchPub, leftElbowThetaPub, leftElbowYawPub);
}
else {
sprintf(buffer,"soulder yaw: %d, soulder pitch: %d, elbow yaw: %d, leftShoulderTheta > 0: %d", leftShoulderYaw - leftShoulderYawNow, leftShoulderPitch - leftShoulderPitchNow, leftElbowYaw - leftElbowYawNow, leftShoulderTheta);
glColor3f(0.7f, 0.8f, 2.0f);
glRasterPos2i(20, 220);
glPrintString(GLUT_BITMAP_HELVETICA_18, buffer);
}
}
if (g_drawFrameId)
{
DrawFrameId(userTrackerFrame.getFrameIndex());
}
if (g_generalMessage[0] != '\0')
{
char *msg = g_generalMessage;
glColor3f(1.0f, 0.0f, 0.0f);
glRasterPos2i(100, 20);
glPrintString(GLUT_BITMAP_HELVETICA_18, msg);
}
// Swap the OpenGL display buffers
glutSwapBuffers();
}
void DrawContext::DrawDrawGroup(DrawGroup* dgroup) {
cur_camera_ = dgroup->GetCamera();
cur_camera_->SetViewportSize(viewport_width_, viewport_height_);
Frustum frustum = cur_camera_;
const QVector3D eye = cur_camera_->WorldTransform().map(QVector3D(0, 0, 0));
// Figure out which nodes to draw and some data about them.
std::vector<DrawNodeData> to_draw;
const int num_draw_nodes = dgroup->DrawNodes().size();
to_draw.reserve(num_draw_nodes);
const bool do_frustum_culling = dgroup->GetFrustumCulling();
for (DrawNode* draw_node : dgroup->DrawNodes()) {
// If the node is not visible, then skip it.
bool visible = true;
for (SceneNode* node = draw_node; node; node = node->ParentNode()) {
if (!node->Visible()) {
visible = false;
break;
}
}
if (!visible) {
continue;
}
// For each draw node, compute:
// - model matrix
// - world frame axis aligned bounding box
// - squared distance to camera
// - view frustum intersection
DrawNodeData dndata;
dndata.node = draw_node;
// Cache the model mat matrix and world frame bounding box
dndata.model_mat = draw_node->WorldTransform();
// Compute the world frame axis-aligned bounding box
dndata.world_bbox = draw_node->WorldBoundingBox();
// View frustum culling
if (do_frustum_culling &&
dndata.world_bbox.Valid() &&
!frustum.Intersects(dndata.world_bbox)) {
continue;
}
dndata.squared_distance = squaredDistanceToAABB(eye,
dndata.world_bbox);
to_draw.push_back(dndata);
}
switch (dgroup->GetNodeOrdering()) {
case NodeOrdering::kBackToFront:
// Sort nodes to draw back to front
std::sort(to_draw.begin(), to_draw.end(),
[](const DrawNodeData& dndata_a, const DrawNodeData& dndata_b) {
return dndata_a.squared_distance > dndata_b.squared_distance;
});
break;
case NodeOrdering::kFrontToBack:
// Sort nodes to draw front to back
std::sort(to_draw.begin(), to_draw.end(),
[](const DrawNodeData& dndata_a, const DrawNodeData& dndata_b) {
return dndata_a.squared_distance < dndata_b.squared_distance;
});
break;
case NodeOrdering::kNone:
default:
// Don't sort nodes
break;
}
// Draw each draw node
for (DrawNodeData& dndata : to_draw) {
const QString name = dndata.node->Name();
model_mat_ = dndata.model_mat;
DrawDrawNode(dndata.node);
if (draw_bounding_boxes_) {
DrawBoundingBox(dndata.world_bbox);
}
}
}
int main(void)
{
// Initialization
//--------------------------------------------------------------------------------------
const int screenWidth = 800;
const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib example - obj viewer");
// Define the camera to look into our 3d world
Camera camera = { { 30.0f, 30.0f, 30.0f }, { 0.0f, 10.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
Model model = LoadModel("resources/models/turret.obj"); // Load default model obj
Texture2D texture = LoadTexture("resources/models/turret_diffuse.png"); // Load default model texture
model.materials[0].maps[MAP_DIFFUSE].texture = texture; // Bind texture to model
Vector3 position = { 0.0, 0.0, 0.0 }; // Set model position
BoundingBox bounds = MeshBoundingBox(model.meshes[0]); // Set model bounds
bool selected = false; // Selected object flag
SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
char objFilename[64] = "turret.obj";
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
if (IsFileDropped())
{
int count = 0;
char **droppedFiles = GetDroppedFiles(&count);
if (count == 1)
{
if (IsFileExtension(droppedFiles[0], ".obj"))
{
for (int i = 0; i < model.meshCount; i++) UnloadMesh(&model.meshes[i]);
model.meshes = LoadMeshes(droppedFiles[0], &model.meshCount);
bounds = MeshBoundingBox(model.meshes[0]);
}
else if (IsFileExtension(droppedFiles[0], ".png"))
{
UnloadTexture(texture);
texture = LoadTexture(droppedFiles[0]);
model.materials[0].maps[MAP_DIFFUSE].texture = texture;
}
strcpy(objFilename, GetFileName(droppedFiles[0]));
}
ClearDroppedFiles(); // Clear internal buffers
}
UpdateCamera(&camera);
// Select model on mouse click
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
{
// Check collision between ray and box
if (CheckCollisionRayBox(GetMouseRay(GetMousePosition(), camera), bounds)) selected = !selected;
else selected = false;
}
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
BeginMode3D(camera);
DrawModel(model, position, 1.0f, WHITE); // Draw 3d model with texture
DrawGrid(20.0, 10.0); // Draw a grid
if (selected) DrawBoundingBox(bounds, GREEN);
EndMode3D();
DrawText("Free camera default controls:", 10, 20, 10, DARKGRAY);
DrawText("- Mouse Wheel to Zoom in-out", 20, 40, 10, GRAY);
DrawText("- Mouse Wheel Pressed to Pan", 20, 60, 10, GRAY);
DrawText("- Alt + Mouse Wheel Pressed to Rotate", 20, 80, 10, GRAY);
DrawText("- Alt + Ctrl + Mouse Wheel Pressed for Smooth Zoom", 20, 100, 10, GRAY);
DrawText("Drag & drop .obj/.png to load mesh/texture.", 10, GetScreenHeight() - 20, 10, DARKGRAY);
DrawText(FormatText("Current file: %s", objFilename), 250, GetScreenHeight() - 20, 10, GRAY);
if (selected) DrawText("MODEL SELECTED", GetScreenWidth() - 110, 10, 10, GREEN);
DrawText("(c) Turret 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
UnloadModel(model); // Unload model
ClearDroppedFiles(); // Clear internal buffers
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}
void SampleViewer::Display()
{
if (g_pause)
return;
nite::UserTrackerFrameRef userTrackerFrame;
nite::Status rc1 = m_pUserTracker->readFrame(&userTrackerFrame);
if (rc1 != nite::STATUS_OK) {
printf("GetNextData failed\n");
return;
}
openni::VideoFrameRef depthFrameSide = userTrackerFrame.getDepthFrame();
int height = depthFrameSide.getHeight();
int width = depthFrameSide.getWidth();
if (!label) {
label = (int *)malloc(width*height*sizeof(int));
}
openni::VideoFrameRef depthFrameTop;
openni::Status rc2 = depthStreamTop.readFrame(&depthFrameTop);
if (rc2 != openni::STATUS_OK) {
printf("GetNextData failed\n");
return;
}
if (m_pTexMap == NULL)
{
// Texture map init
m_nTexMapX = MIN_CHUNKS_SIZE(depthFrameSide.getVideoMode().getResolutionX(), TEXTURE_SIZE);
m_nTexMapY = MIN_CHUNKS_SIZE(depthFrameSide.getVideoMode().getResolutionY(), TEXTURE_SIZE);
m_pTexMap = new openni::RGB888Pixel[m_nTexMapX * m_nTexMapY];
}
const nite::UserMap& userLabels = userTrackerFrame.getUserMap();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, GL_WIN_SIZE_X, GL_WIN_SIZE_Y, 0, -1.0, 1.0);
if (depthFrameSide.isValid() && g_drawDepth)
{
calculateHistogram(m_pDepthHistSide, MAX_DEPTH, depthFrameSide);
}
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
if (depthFrameSide.isValid() && g_drawDepth)
{
const nite::UserId* pLabels = userLabels.getPixels();
const openni::DepthPixel* pDepthRow = (const openni::DepthPixel*)depthFrameSide.getData();
openni::RGB888Pixel* pTexRow = m_pTexMap + depthFrameSide.getCropOriginY() * m_nTexMapX;
int rowSize = depthFrameSide.getStrideInBytes() / sizeof(openni::DepthPixel);
for (int y = 0; y < height; ++y)
{
const openni::DepthPixel* pDepth = pDepthRow;
openni::RGB888Pixel* pTex = pTexRow + depthFrameSide.getCropOriginX();
for (int x = 0; x < width; ++x, ++pDepth, ++pTex, ++pLabels)
{
if (*pDepth != 0)
{
if (*pLabels == 0)
{
if (!g_drawBackground)
{
factor[0] = factor[1] = factor[2] = 0;
}
else
{
factor[0] = Colors[colorCount][0];
factor[1] = Colors[colorCount][1];
factor[2] = Colors[colorCount][2];
}
}
else
{
factor[0] = Colors[*pLabels % colorCount][0];
factor[1] = Colors[*pLabels % colorCount][1];
factor[2] = Colors[*pLabels % colorCount][2];
}
// // Add debug lines - every 10cm
// else if ((*pDepth / 10) % 10 == 0)
// {
// factor[0] = factor[2] = 0;
// }
int nHistValue = m_pDepthHistSide[*pDepth];
pTex->r = nHistValue*factor[0];
pTex->g = nHistValue*factor[1];
pTex->b = nHistValue*factor[2];
factor[0] = factor[1] = factor[2] = 1;
}
}
pDepthRow += rowSize;
pTexRow += m_nTexMapX;
}
}
const openni::DepthPixel *imgBufferSide = (const openni::DepthPixel *)depthFrameSide.getData();
const openni::DepthPixel *imgBufferTop = (const openni::DepthPixel *)depthFrameTop.getData();
calculateHistogram(m_pDepthHistTop, MAX_DEPTH, depthFrameTop);
imgTop = Mat(depthFrameTop.getHeight(), depthFrameTop.getWidth(), CV_8UC3);
Mat(depthFrameTop.getHeight(), depthFrameTop.getWidth(), CV_16U, (void *)imgBufferTop).convertTo(depthTop, CV_8U, 1.0/256);
for (int i = 0; i < imgTop.rows; i++) {
for (int j = 0; j < imgTop.cols; j++) {
int val = (int)m_pDepthHistTop[imgBufferTop[j + i*imgTop.cols]];
imgTop.at<Vec3b>(i, j).val[0] = val;
imgTop.at<Vec3b>(i, j).val[1] = val;
imgTop.at<Vec3b>(i, j).val[2] = val;
}
}
if (g_getBackground)
bgSubtractor->processImages(depthTop);
bgSubtractor->getMask(depthTop, mask);
imshow("Mask", mask);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_nTexMapX, m_nTexMapY, 0, GL_RGB, GL_UNSIGNED_BYTE, m_pTexMap);
// Display the OpenGL texture map
glColor4f(1,1,1,1);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
// 320x240
g_nXRes = depthFrameSide.getVideoMode().getResolutionX();
g_nYRes = depthFrameSide.getVideoMode().getResolutionY();
// upper left
glTexCoord2f(0, 0);
glVertex2f(0, 0);
// upper right
glTexCoord2f((float)g_nXRes/(float)m_nTexMapX, 0);
glVertex2f(GL_WIN_SIZE_X, 0);
// bottom right
glTexCoord2f((float)g_nXRes/(float)m_nTexMapX, (float)g_nYRes/(float)m_nTexMapY);
glVertex2f(GL_WIN_SIZE_X, GL_WIN_SIZE_Y);
// bottom left
glTexCoord2f(0, (float)g_nYRes/(float)m_nTexMapY);
glVertex2f(0, GL_WIN_SIZE_Y);
glEnd();
glDisable(GL_TEXTURE_2D);
const nite::Array<nite::UserData>& users = userTrackerFrame.getUsers();
float maxSize = -1;
int maxIdx = -1;
for (int i = 0; i < users.getSize(); ++i) {
const nite::UserData &user = users[i];
if (!user.isVisible())
continue;
if (getSize(user) > maxSize) {
maxSize = getSize(user);
maxIdx = i;
}
//printf("user %d: size=%f\n, lost=%d, new=%d, visible=%d\n",
// i, getSize(user), user.isLost(), user.isNew(), user.isVisible());
}
for (int i = 0; i < users.getSize(); ++i)
{
const nite::UserData &user = users[i];
updateUserState(user, userTrackerFrame.getTimestamp());
if (user.isNew())
{
m_pUserTracker->startSkeletonTracking(user.getId());
m_pUserTracker->startPoseDetection(user.getId(), nite::POSE_CROSSED_HANDS);
}
else if (!user.isLost())
{
if (g_drawStatusLabel) {
DrawStatusLabel(m_pUserTracker, user);
}
if (g_drawCenterOfMass) {
DrawCenterOfMass(m_pUserTracker, user);
}
if (g_drawBoundingBox) {
DrawBoundingBox(user);
}
if (users[i].getSkeleton().getState() == nite::SKELETON_TRACKED && g_drawSkeleton) {
if (maxIdx == i) {
DrawSkeleton(m_pUserTracker, user);
sideSkel.setTo(Scalar(0, 0, 0));
drawSkeleton(sideSkel, sideJoints);
topSkel.setTo(Scalar(0, 0, 0));
drawSkeleton(topSkel, topJoints);
drawSkeleton(imgTop, topJoints);
}
}
}
// exit the program after a few seconds if PoseType == POSE_CROSSED_HANDS
if (m_poseUser == 0 || m_poseUser == user.getId())
{
const nite::PoseData& pose = user.getPose(nite::POSE_CROSSED_HANDS);
if (pose.isEntered())
{
// Start timer
sprintf(g_generalMessage, "In exit pose. Keep it for %d second%s to exit\n", g_poseTimeoutToExit/1000, g_poseTimeoutToExit/1000 == 1 ? "" : "s");
printf("Counting down %d second to exit\n", g_poseTimeoutToExit/1000);
m_poseUser = user.getId();
m_poseTime = userTrackerFrame.getTimestamp();
}
else if (pose.isExited())
{
memset(g_generalMessage, 0, sizeof(g_generalMessage));
printf("Count-down interrupted\n");
m_poseTime = 0;
m_poseUser = 0;
}
else if (pose.isHeld())
{
// tick
if (userTrackerFrame.getTimestamp() - m_poseTime > g_poseTimeoutToExit * 1000)
{
printf("Count down complete. Exit...\n");
Finalize();
exit(2);
}
}
}
}
if (g_drawFrameId)
{
DrawFrameId(userTrackerFrame.getFrameIndex());
}
if (g_generalMessage[0] != '\0')
{
char *msg = g_generalMessage;
glColor3f(1.0f, 0.0f, 0.0f);
glRasterPos2i(100, 20);
glPrintString(GLUT_BITMAP_HELVETICA_18, msg);
}
imshow("Side", sideSkel);
imshow("Top", topSkel);
imshow("DepthTop", imgTop);
if (!g_getBackground) {
knnsearch(topJoints, imgBufferTop, mask, labelTop, label, 320, 240);
drawSkeleton(labelTop, topJoints);
cv::resize(labelTop, labelTop, Size(), 2, 2);
imshow("Label", labelTop);
if (g_capture2) {
// c style
string path = outDir + "/depth-top" + to_string(nFrame) + ".txt";
FILE *f = fopen(path.c_str(), "w");
for (int i = 0; i < width*height; i++) {
fprintf(f, "%u\n", imgBufferTop[i]);
}
fclose(f);
path = outDir + "/depth-side" + to_string(nFrame) + ".txt";
f = fopen(path.c_str(), "w");
for (int i = 0; i < width*height; i++) {
fprintf(f, "%u\n", imgBufferSide[i]);
}
fclose(f);
path = outDir + "/joints-top" + to_string(nFrame) + ".txt";
f = fopen(path.c_str(), "w");
for (int i = 0; i < N_JOINTS; i++) {
fprintf(f, "%f, %f, %f, %f, %f\n", topJoints[i][0], topJoints[i][1],
topJoints[i][2], topJoints[i][3], topJoints[i][4]);
}
fclose(f);
path = outDir + "/joints-side" + to_string(nFrame) + ".txt";
f = fopen(path.c_str(), "w");
for (int i = 0; i < N_JOINTS; i++) {
fprintf(f, "%f, %f, %f, %f, %f\n", sideJoints[i][0], sideJoints[i][1],
sideJoints[i][2], sideJoints[i][3], sideJoints[i][4]);
}
fclose(f);
path = outDir + "/label-top" + to_string(nFrame) + ".txt";
f = fopen(path.c_str(), "w");
for (int i = 0; i < width*height; i++) {
fprintf(f, "%d\n", label[i]);
}
fclose(f);
path = outDir + "/label-side" + to_string(nFrame) + ".txt";
f = fopen(path.c_str(), "w");
const nite::UserId* labelsTop = userLabels.getPixels();
for (int i = 0; i < width*height; i++) {
fprintf(f, "%d\n", (int)labelsTop[i]);
}
fclose(f);
nFrame++;
}
}
// Swap the OpenGL display buffers
glutSwapBuffers();
}
void Transform::DrawOverlay(X3DDrawContext* pDC)
{
Vec3f S = getScale();
if (S[0] == 0 && S[1] == 0 && S[2] == 0)
return;
D3DXMATRIX transform = GetTransform();
pDC->m_renderContext->PushModelView(transform * pDC->m_renderContext->modelViewMatrix());
// TODO: not here
if (m_selected)
{
// pDC->m_renderContext->PushModelView(pDC->m_renderContext->modelViewMatrix() * MatrixTranslation(getLocation()));
D3DXMATRIX m = pDC->m_renderContext->modelViewMatrix();
DrawBoundingBox(pDC, CalculateBoundingBox(*(gm::matrix4f*)&m));
DrawAxis(pDC);
// pDC->m_renderContext->PopMatrix();
// pDC->m_renderContext->GetRT()->m_d3d10->m_device->OMSetDepthStencilState(depthStencilState, stencilRef);
}
DrawOverlayChildren(pDC, getChildrenField());
pDC->m_renderContext->PopMatrix();
#if 0
/*
SFVec3f* C = static_cast<SFVec3f*>(m_C);
SFRotation* R = static_cast<SFRotation*>(m_R);
SFVec3f* S = static_cast<SFVec3f*>(m_S);
SFVec3f* SR = static_cast<SFVec3f*>(m_SR);
SFVec3f* T = static_cast<SFVec3f*>(m_T);
MFNode* children = static_cast<MFNode*>(m_children);
*/
pDC->m_pGraphics3D->glPushMatrix();
pDC->m_pGraphics3D->glTranslate(m_T->m_value);
pDC->m_pGraphics3D->glTranslate(m_C->m_value);
pDC->m_pGraphics3D->glRotate(gmDegrees(m_R->m_value.m_angle), m_R->m_value.m_axis);
pDC->m_pGraphics3D->glRotate(gmDegrees(m_SR->m_value.m_angle), m_SR->m_value.m_axis);
pDC->m_pGraphics3D->glScale(m_S->m_value);
pDC->m_pGraphics3D->glRotate(gmDegrees(m_SR->m_value.m_angle), -m_SR->m_value.m_axis);
pDC->m_pGraphics3D->glTranslate(-m_C->m_value);
// Draw axes
{
//DrawBoundBox();
pDC->m_pGraphics3D->glPushAttrib(GL_ENABLE_BIT);
float len = 4;
pDC->m_pGraphics3D->glDisable(GL_LIGHTING);
pDC->m_pGraphics3D->glBegin(GL_LINES);
pDC->m_pGraphics3D->glColorf(1.0, 0, 0); // red
pDC->m_pGraphics3D->glVertexf(0, 0, 0);
pDC->m_pGraphics3D->glVertexf(1*len, 0, 0);
pDC->m_pGraphics3D->glColorf(0.0, 1.0, 0); // blue
pDC->m_pGraphics3D->glVertexf(0, 0, 0);
pDC->m_pGraphics3D->glVertexf(0, 1*len, 0);
pDC->m_pGraphics3D->glColorf(0, 0, 1.0); // green
pDC->m_pGraphics3D->glVertexf(0, 0, 0);
pDC->m_pGraphics3D->glVertexf(0, 0, 1*len);
pDC->m_pGraphics3D->glEnd();
pDC->m_pGraphics3D->glColorf(1,1,1); // white
// GLUquadricObj* q = gluNewQuadric();
LDraw::gluSphere(pDC->m_pGraphics3D, 0.1, 8, 8);
// gluDeleteQuadric(q);
pDC->m_pGraphics3D->glPopAttrib();
}
int nLight = pDC->m_nLight;
int i;
for (i = 0; i < m_children->m_items.GetSize(); i++)
{
if (m_children->m_items[i])
{
CLRenderImplImpl* render = dynamic_cast<CLRenderImplImpl*>(m_children->m_items[i]->GetNode());
if (render)
{
render->PreDraw(pDC);
}
}
}
for (i = 0; i < m_children->m_items.GetSize(); i++)
{
if (m_children->m_items[i])
{
CLRenderImplImpl* render = dynamic_cast<CLRenderImplImpl*>(m_children->m_items[i]->GetNode());
if (render)
{
render->DrawOverlay(pDC);
}
}
}
for (i = pDC->m_nLight; i >= nLight; i--)
{
pDC->m_pGraphics3D->glDisable(GL_LIGHT0+i);
}
pDC->m_nLight = nLight;
pDC->m_pGraphics3D->glPopMatrix();
#endif
}
// Rendering entrance function
void MeshModelRender::DrawModel()
{
// set the default material here.
m_DefaultMaterial.SetMaterial();
Utility util;
// Whether show axis
if(util.IsSetFlag(m_State, RENDER_MODEL_AXIS))
DrawAxis();
// Whether show bounding box
if(util.IsSetFlag(m_State, RENDER_MODEL_BOUNDING_BOX))
DrawBoundingBox();
// Whether lighting
if(util.IsSetFlag(m_State, RENDER_MODEL_LIGHTING))
glEnable(GL_LIGHTING);
else
glDisable(GL_LIGHTING);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_POLYGON_SMOOTH);
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
// Whether per-element color
if(util.IsSetFlag(m_State, RENDER_MODEL_COLOR))
{
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
}
else
glDisable(GL_COLOR_MATERIAL);
switch(m_Mode) {
case RENDER_MODEL_VERTICES:
DrawModelDepth();
DrawModelVertices();
break;
case RENDER_MODEL_WIREFRAME:
DrawModelDepth();
DrawModelWireframe();
break;
case RENDER_MODEL_SOLID_FLAT:
DrawModelSolidFlat();
break;
case RENDER_MODEL_SOLID_SMOOTH:
DrawModelSolidSmooth();
break;
case RENDER_MODEL_SOLID_WITH_SHARPNESS:
DrawModelSolidWithSharpness();
break;
case RENDER_MODEL_SOLID_AND_WIREFRAME:
DrawModelSolidAndWireframe();
break;
case RENDER_MODEL_HIGHLIGHT_ONLY:
DrawModelHighlightOnly();
break;
case RENDER_MODEL_TEXTURE_MAPPING:
DrawModelTextureMapping();
break;
case RENDER_MODEL_VERTEX_COLOR:
DrawModelVertexColor();
break;
case RENDER_MODEL_FACE_COLOR:
DrawModelFaceColor();
break;
case RENDER_MODEL_TRANSPARENT:
DrawModelTransparent();
break;
case RENDER_MODEL_PARAM_TEXTURE:
DrawModelFaceTexture();
break;
}
glDisable(GL_LIGHTING);
if(util.IsSetFlag(m_State, RENDER_MODEL_POINT))
DrawPoint();
if(util.IsSetFlag(m_State, RENDER_MODEL_LINE))
DrawLine();
if(util.IsSetFlag(m_State, RENDER_MODEL_POLYGON))
DrawPolygon();
// draw kmax and kmin here.
if(util.IsSetFlag(m_State, RENDER_MODEL_KMAX_CURVATURE)
|| util.IsSetFlag(m_State, RENDER_MODEL_KMIN_CURVATURE))
{
DrawMeshCurvature(m_State);
}
glEnable(GL_LIGHTING);
}
