OpenGL -绕Y轴旋转“曲线”

hjqgdpho  于 2024-01-07  发布在  其他
关注(0)|答案(3)|浏览(234)
  • 根据我在Math Stackexchange上的question：*

我正在为我的3D图形类做一个项目。这个项目是用C++和OpenGL / Glut构建的。基本上，我创建了一个水平的矩形窗口，细分为两个正方形。在左边，我有一个二维坐标平面，它允许用户指向并单击并定义一个剖面“曲线”。然后我需要将这个曲线绕Y轴缠绕n次。
那么，有人能指导我如何使用三角函数来计算连续点的X和Z值吗？例如，如果用户单击并创建点：
（1，1，0）
并且它们的扫描分辨率（n）设置为，比如说，10，那么我需要围绕Y轴每隔36（360/10）度重新绘制该点。
我假设三角学可以帮助我吗？如果是这样，有人能告诉我一点关于如何计算在3D空间中平移点的位置吗？自从我学习三角学以来已经有一段时间了，我不相信我们曾经离开过2D空间。

编辑：尝试用途：

  1. x'=xcos(theta)-zsin(theta)
  3. y'=y
  5. z'=xsin(theta)+zcos(theta)

字符串
根据我对安培瑞恩的回答的理解，我不认为它像我希望的那样起作用：

  1. // this is in a loop
  3. // setup the new angle
  4. double angle = i>0 ? (360/sweepResolutionMod)*i : 0;
  6. angle = angle * (M_PI/180);
  8. // for each point...
  9. for( int i=0; i<clickedPoints.size(); i++ )
  10. {
  11.     // initial point, normalized
  12.     GLfloat tempX = (clickedPoints[i].x-250)/250;
  13.     GLfloat tempY = (clickedPoints[i].y-250)/250;
  14.     GLfloat tempZ = 0.0;
  16.     // log the initial point
  17.     cout << "(" << tempX << ", " << tempY << ", 0.0) by " << angle << " radians = ";
  19.     // generate the new point
  20.     GLfloat newX = (tempX * cos(angle)) - (tempZ * sin(angle));
  21.     GLfloat newY = tempY;
  22.     GLfloat newZ = (tempX * sin(angle)) - (tempZ * cos(angle));
  24.     // log the new point
  25.     cout << "(" << newX << ", " << newY << ", " << newZ << ")\n";
  27.     // render the new point
  28.     glVertex3d(newX, newY, newZ);
  29. }

型
这不会产生屏幕输出，但会产生控制台输出：

  1. (0.048, -0.296, 0.0) by 0 radians = (0.048, -0.296, 0)
  2. (0.376, -0.508, 0.0) by 0 radians = (0.376, -0.508, 0)
  3. (0.72, -0.204, 0.0) by 0 radians = (0.72, -0.204, 0)
  4. (0.652, 0.176, 0.0) by 0 radians = (0.652, 0.176, 0)
  5. (0.368, 0.504, 0.0) by 0 radians = (0.368, 0.504, 0)
  7. (0.048, -0.296, 0.0) by 0.628319 radians = (0.0388328, -0.296, 0.0282137)
  8. (0.376, -0.508, 0.0) by 0.628319 radians = (0.30419, -0.508, 0.221007)
  9. (0.72, -0.204, 0.0) by 0.628319 radians = (0.582492, -0.204, 0.423205)
  10. (0.652, 0.176, 0.0) by 0.628319 radians = (0.527479, 0.176, 0.383236)
  11. (0.368, 0.504, 0.0) by 0.628319 radians = (0.297718, 0.504, 0.216305)
  13. (0.048, -0.296, 0.0) by 1.25664 radians = (0.0148328, -0.296, 0.0456507)
  14. (0.376, -0.508, 0.0) by 1.25664 radians = (0.11619, -0.508, 0.357597)
  15. (0.72, -0.204, 0.0) by 1.25664 radians = (0.222492, -0.204, 0.684761)
  16. (0.652, 0.176, 0.0) by 1.25664 radians = (0.201479, 0.176, 0.620089)
  17. (0.368, 0.504, 0.0) by 1.25664 radians = (0.113718, 0.504, 0.349989)
  19. ...
  21. (0.048, -0.296, 0.0) by 6.28319 radians = (0.048, -0.296, -1.17566e-17)
  22. (0.376, -0.508, 0.0) by 6.28319 radians = (0.376, -0.508, -9.20934e-17)
  23. (0.72, -0.204, 0.0) by 6.28319 radians = (0.72, -0.204, -1.76349e-16)
  24. (0.652, 0.176, 0.0) by 6.28319 radians = (0.652, 0.176, -1.59694e-16)
  25. (0.368, 0.504, 0.0) by 6.28319 radians = (0.368, 0.504, -9.0134e-17)

型
我不知道到底是怎么回事，但我有一个可怕的时间试图弄清楚，所以请不要认为我试图获得双重声誉或任何东西，我只是真的卡住了。

编辑2：下面是我的透视子视图的整个显示例程：

  1. void displayPersp(void)
  2. {
  3.     glClear(GL_COLOR_BUFFER_BIT);
  5.     glMatrixMode (GL_MODELVIEW);
  6.     glLoadIdentity ();  
  8.     gluLookAt (-2.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0);
  10.     // draw the axis
  11.     glBegin(GL_LINES);
  12.     // x
  13.     glVertex3f(500.0, 0.0, 0.0);
  14.     glVertex3f(-500.0, 0.0, 0.0);
  15.     // y
  16.     glVertex3f(0.0, -500.0, 0.0);
  17.     glVertex3f(0.0, 500.0, 0.0);
  18.     // z
  19.     glVertex3f(0.0, 0.0, -500.0);
  20.     glVertex3f(0.0, 0.0, 500.0);
  22.     glEnd(); 
  24.     cout << endl;
  26.     // loop as many number of times as we are going to draw the points around the Y-Axis
  27.     for( int i=0; i<=sweepResolutionMod; i++ )
  28.     {
  29.         cout << endl;
  31.         // setup the new angle
  32.         double angle = i>0 ? (360/sweepResolutionMod)*i : 0;
  34.         angle = angle * (M_PI/180);
  36.         // for each point...
  37.         for( int i=0; i<clickedPoints.size(); i++ )
  38.         {
  39.             GLfloat tempX = (clickedPoints[i].x-250)/250;
  40.             GLfloat tempY = (clickedPoints[i].y-250)/250;
  41.             GLfloat tempZ = 0.0;
  43.             cout << "(" << tempX << ", " << tempY << ", 0.0) by " << angle << " degrees = ";
  45.             GLfloat newX = (tempX * cos(angle)) - (tempZ * sin(angle));
  46.             GLfloat newY = tempY;
  47.             GLfloat newZ = (tempX * sin(angle)) - (tempZ * cos(angle));
  49.             cout << "(" << newX << ", " << newY << ", " << newZ << ")\n";
  51.             glVertex3d(newX, newY, newZ);
  52.         }
  54.         // the following was my old solution, using OpenGL's rotate(), but that
  55.         // didn't allow me to get back the new point's coordinates.
  57.         /*
  58.         glRotatef(angle, 0.0, 1.0, 0.0);
  60.         // draw a line?
  61.         if( clickedPoints.size() > 1 )
  62.         {
  63.             glBegin(GL_LINE_STRIP);
  65.             for(int i=0; i<clickedPoints.size(); i++ )
  66.             {     
  67.                 glVertex3f((clickedPoints[i].x-250)/250, (clickedPoints[i].y-250)/250, 0.0);     
  68.             }
  70.             glEnd();
  71.         }
  73.         // everyone gets points
  74.         glBegin(GL_POINTS);
  76.         for(int i=0; i<clickedPoints.size(); i++ )
  77.         { 
  78.             glVertex3f((clickedPoints[i].x-250)/250, (clickedPoints[i].y-250)/250, 0.0);     
  79.         }
  81.         glEnd();
  82.         */
  83.     }
  85.     glutSwapBuffers();
  86. }

型
编辑3：这里有一个很糟糕的例子来说明我需要做什么。我知道透视图看起来不对，但我试图在右边的子视图中获取绿色的“水平线”（这是使用上面注解掉的glRotatef（）代码）：
x1c 0d1x的数据

最后编辑（为了子孙后代！）：

这是我在大学里和一位老师讨论了一些线性代数之后，最终得到的工作：

  1. void displayPersp(void)
  2. {
  3.    glClear(GL_COLOR_BUFFER_BIT);
  5.    gluLookAt (-2.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0);
  7.    glMatrixMode (GL_MODELVIEW);
  8.    glLoadIdentity ();  
  10.    // draw the axis
  11.    glBegin(GL_LINES);
  12.      // x
  13.      glVertex3f(500.0, 0.0, 0.0);
  14.      glVertex3f(-500.0, 0.0, 0.0);
  15.      // y
  16.      glVertex3f(0.0, -500.0, 0.0);
  17.      glVertex3f(0.0, 500.0, 0.0);
  18.      // z
  19.      glVertex3f(0.0, 0.0, -500.0);
  20.      glVertex3f(0.0, 0.0, 500.0);
  22.    glEnd(); 
  24.    cout << endl;
  26.    double previousTheta = 0.0;
  28.    for( int i=0; i<=sweepResolutionMod; i++ )
  29.    {
  30.      double theta = i>0 ? (360/sweepResolutionMod)*i : 0;
  32.      theta = theta * (M_PI/180);
  34.      if( clickedPoints.size() > 1 )
  35.      {
  36.        // the 'vertical' piece
  37.        glBegin(GL_LINE_STRIP);
  39.        for(int i=0; i<clickedPoints.size(); i++ )
  40.        {     
  41.          // normalize
  42.          GLfloat tempX = (clickedPoints[i].x-250)/250;
  43.          GLfloat tempY = (clickedPoints[i].y-250)/250;
  44.          GLfloat tempZ = 0.0;
  46.          // new points
  47.          GLfloat newX = ( tempX * cos(theta) ) + ( tempZ * sin(theta) );
  48.          GLfloat newY = tempY;
  49.          GLfloat newZ = ( tempZ * cos(theta) ) - ( tempX * sin(theta) );
  51.          glVertex3f(newX, newY, newZ);     
  52.        }
  54.        glEnd();
  56.        // the 'horizontal' piece
  57.        if( previousTheta != theta )
  58.        {
  59.          glBegin(GL_LINES);
  61.          for(int i=0; i<clickedPoints.size(); i++ )
  62.          {     
  63.            // normalize
  64.            GLfloat tempX = (clickedPoints[i].x-250)/250;
  65.            GLfloat tempY = (clickedPoints[i].y-250)/250;
  66.            GLfloat tempZ = 0.0;
  68.            // new points
  69.            GLfloat newX = ( tempX * cos(theta) ) + ( tempZ * sin(theta) );
  70.            GLfloat newY = tempY;
  71.            GLfloat newZ = ( tempZ * cos(theta) ) - ( tempX * sin(theta) );
  73.            // previous points
  74.            GLfloat previousX = ( tempX * cos(previousTheta) ) + ( tempZ * sin(previousTheta) );
  75.            GLfloat previousY = tempY;
  76.            GLfloat previousZ = ( tempZ * cos(previousTheta) ) - ( tempX * sin(previousTheta) );
  78.            // horizontal component           
  79.            glVertex3f(newX, newY, newZ);     
  80.            glVertex3f(previousX, previousY, previousZ);     
  81.          }
  83.          glEnd();
  84.        }
  85.      }
  87.      previousTheta = theta;
  88.    }
  90.    glutSwapBuffers();
  91. }

型

opengl

3条答案

按热度按时间
rbpvctlc

rbpvctlc1#

看起来你正在尝试构造一个surface of revolution/solid of revolution/"lathe object"。
一个工作示例：
x1c 0d1x的数据

  1. #include <GL/glut.h>
  2. #include <glm/glm.hpp>
  3. #include <vector>
  4. #include <cmath>
  6. using namespace std;
  7. using namespace glm;
  9. struct Vertex
  10. {
  11.     Vertex( const vec3& position, const vec3& normal )
  12.         : position( position )
  13.         , normal( normal ) 
  14.     {}
  15.     vec3 position;
  16.     vec3 normal;
  17. };
  19. // spin the pts array around the Z axis.
  20. // pts.x will become the radius, and pts.y will become the height
  21. // pts should be sorted by y-coordinate
  22. vector< Vertex > Lathe( const vector< vec2 >& pts, unsigned int segments = 32 )
  23. {
  24.     // precalculate circle points
  25.     vector< vec2 > circlePts;
  26.     for( unsigned int i = 0; i <= segments; ++i )
  27.     {
  28.         float angle = ( i / (float)segments ) * 3.14159f * 2.0f;
  29.         circlePts.push_back( vec2( cos( angle ), sin( angle ) ) );
  30.     }
  32.     // fill each layer
  33.     typedef vector< vec3 > Layer;
  34.     typedef vector< Layer > Layers;
  35.     Layers layers( pts.size(), Layer( circlePts.size() ) );
  36.     for( size_t i = 0; i < pts.size(); ++i )
  37.     {
  38.         for( unsigned int j = 0; j < circlePts.size(); ++j )
  39.         {
  40.             layers[i][j] = vec3( circlePts[j] * pts[i].x, pts[i].y );
  41.         }
  42.     }
  44.     // move through layers generating triangles
  45.     vector< Vertex > verts;
  46.     for( size_t i = 1; i < layers.size(); ++i )
  47.     {
  48.         const Layer& prvLayer = layers[ i-1 ];
  49.         const Layer& curLayer = layers[ i-0 ];
  50.         for( size_t j = 1; j < circlePts.size(); ++j )
  51.         {
  52.             //    upper = cur layer
  53.             //        UL -- UR  
  54.             // left   | 0 /  |  right 
  55.             // = j-1  |  / 1 |  = j-0
  56.             //        LL -- LR  
  57.             //    lower = prv layer
  58.             const vec3& LL = prvLayer[ j-1 ]; // lower-left
  59.             const vec3& LR = prvLayer[ j-0 ]; // lower-right
  60.             const vec3& UL = curLayer[ j-1 ]; // upper-left
  61.             const vec3& UR = curLayer[ j-0 ]; // upper-right
  63.             // triangle0: LL -> UR -> UL
  64.             const vec3 normal0 = normalize( cross( UR - LL, UL - LL ) );
  65.             verts.push_back( Vertex( LL, normal0 ) );
  66.             verts.push_back( Vertex( UR, normal0 ) );
  67.             verts.push_back( Vertex( UL, normal0 ) );
  69.             // triangle1: LL -> LR -> UR
  70.             const vec3 normal1 = normalize( cross( LR - LL, UL - LL ) );
  71.             verts.push_back( Vertex( LL, normal1 ) );
  72.             verts.push_back( Vertex( LR, normal1 ) );
  73.             verts.push_back( Vertex( UR, normal1 ) );
  74.         }
  75.     }
  77.     return verts;
  78. }
  80. // mouse state
  81. int btn;
  82. ivec2 startMouse;
  83. ivec2 startRot, curRot;
  85. void mouse(int button, int state, int x, int y )
  86. {
  87.     if( button == GLUT_LEFT_BUTTON && state == GLUT_DOWN )
  88.     {
  89.         btn = button;
  90.         startMouse = ivec2( x, glutGet( GLUT_WINDOW_HEIGHT ) - y );
  91.         startRot = curRot;
  92.     }
  93. }
  95. void motion( int x, int y )
  96. {
  97.     ivec2 curMouse( x, glutGet( GLUT_WINDOW_HEIGHT ) - y );
  98.     if( btn == GLUT_LEFT_BUTTON )
  99.     {
  100.         curRot = startRot + ( curMouse - startMouse );
  101.     }
  102.     glutPostRedisplay();
  103. }
  105. vector< Vertex > model;
  106. void display()
  107. {
  108.     glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  110.     glMatrixMode( GL_PROJECTION );
  111.     glLoadIdentity();
  112.     double w = glutGet( GLUT_WINDOW_WIDTH );
  113.     double h = glutGet( GLUT_WINDOW_HEIGHT );
  114.     double ar = w / h;
  115.     gluPerspective( 60, ar, 0.1, 40 );
  117.     glMatrixMode( GL_MODELVIEW );
  118.     glLoadIdentity();
  119.     glTranslatef( 0, 0, -10 );
  121.     glPushMatrix();
  122.     glRotatef( curRot.x % 360, 0, 1, 0 );
  123.     glRotatef( -curRot.y % 360, 1, 0, 0 );
  125.     // draw model
  126.     if( !model.empty() )
  127.     {
  128.         glColor3ub( 255, 0, 0 );
  129.         glEnableClientState( GL_VERTEX_ARRAY );
  130.         glEnableClientState( GL_NORMAL_ARRAY );
  131.         glVertexPointer( 3, GL_FLOAT, sizeof(Vertex), &model[0].position );
  132.         glNormalPointer( GL_FLOAT, sizeof(Vertex), &model[0].normal );
  133.         glDrawArrays( GL_TRIANGLES, 0, model.size() );
  134.         glDisableClientState( GL_VERTEX_ARRAY );
  135.         glDisableClientState( GL_NORMAL_ARRAY );
  136.     }
  138.     // draw bounding cube
  139.     glDisable( GL_LIGHTING );
  140.     glColor3ub( 255, 255, 255 );
  141.     glutWireCube( 7 );
  142.     glEnable( GL_LIGHTING );
  144.     glPopMatrix();
  146.     glutSwapBuffers();
  147. }
  149. int main( int argc, char **argv )
  150. {
  151.     vector< vec2 > pts;
  152.     pts.push_back( vec2( 0.1, -3 ) );
  153.     pts.push_back( vec2( 2, -2 ) );
  154.     pts.push_back( vec2( 3, -1 ) );
  155.     pts.push_back( vec2( 1, 0 ) );
  156.     pts.push_back( vec2( 3, 1 ) );
  157.     pts.push_back( vec2( 4, 2 ) );
  158.     pts.push_back( vec2( 4, 3 ) );
  159.     model = Lathe( pts );
  161.     glutInit( &argc, argv );
  162.     glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
  163.     glutInitWindowSize( 640, 480 );
  164.     glutCreateWindow( "GLUT" );
  165.     glutDisplayFunc( display );
  166.     glutMouseFunc( mouse );
  167.     glutMotionFunc( motion );
  169.     glEnable( GL_DEPTH_TEST );
  171.     // set up lighting
  172.     glShadeModel( GL_SMOOTH );
  173.     glEnable( GL_COLOR_MATERIAL );
  174.     glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE ) ;
  175.     glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
  176.     glEnable( GL_LIGHTING );
  178.     // set up "headlamp"-like light
  179.     glEnable( GL_LIGHT0 );
  180.     glMatrixMode( GL_MODELVIEW );
  181.     glLoadIdentity();
  182.     GLfloat position[] = { 0, 0, 1, 0 };
  183.     glLightfv( GL_LIGHT0, GL_POSITION, position );
  185.     glPolygonMode( GL_FRONT, GL_FILL );
  186.     glPolygonMode( GL_BACK, GL_LINE );
  188.     glutMainLoop();
  189.     return 0;
  190. }

字符串

展开查看全部
赞(0）分享  回复(0）举报  2024-01-07
vmpqdwk3

vmpqdwk32#

编辑二：好吧，我知道你遇到的问题了--这是一个我忘记的限制（所以我之前发布的代码是完全错误的，根本不能工作）。问题是不允许在glBegin/glEnd对之间调用glRotate--如果你这样做了，它会设置一个错误标志，并且不会再进行绘制。
这意味着你必须自己处理旋转。幸运的是，这比你试图做的要简单一些：

  1. static const double pi = 3.1416;
  3. for (int point=0; point<NUM_POINTS; point++) {
  4.     glBegin(GL_LINE_STRIP);
  5.     for (double theta = 0.0; theta < 2.0 * pi; theta += pi/6.0) {
  6.         double x = cos(theta);
  7.         double z = sin(theta);
  8.         glVertex3d(points[point][0]*x, points[point][1], -1.0-points[point][0]*z);
  9.     }
  10.     glEnd();
  11. }

字符串
这段代码使用沿着Z轴的-1.0作为旋转中心，你可以随意移动它，但是剪切截头体之外的任何东西都不会显示。
还要注意的是，要得到一个线框，你必须分别绘制“垂直”和“水平”线，所以代码看起来像这样：

  1. for (int point=0; point<NUM_POINTS; point++) {
  2.     glBegin(GL_LINE_STRIP);
  3.     for (double theta = 0.0; theta < 2.0 * pi; theta += pi/6.0) {
  4.         double x = cos(theta);
  5.         double z = sin(theta);
  6.         glVertex3d(points[point][0]*x, points[point][1], -1.0 - points[point][0]*z);
  7.     }
  8.     glEnd();
  9. }
  11. for (double theta = 0.0; theta < 2.0 * pi; theta += pi/6.0) {
  12.     glBegin(GL_LINE_STRIP);
  13.     for (int point=0; point<NUM_POINTS; point++) {
  14.         double x = cos(theta);
  15.         double z = sin(theta);
  16.         glVertex3d(points[point][0]*x, points[point][1], -1.0 - points[point][0]*z);
  17.     }
  18.     glEnd();
  19. }

型

展开查看全部
赞(0）分享  回复(0）举报  2024-01-07
vd2z7a6w

vd2z7a6w3#

函数的Angular 单位是弧度，而不是度。
我还怀疑你的视口设置不正确，这解释了为什么你在屏幕上看不到任何东西。通常当我认为东西没有渲染时，它通常是，然而，我没有正确配置相机，灯光和其他东西。

赞(0）分享  回复(0）举报  2024-01-07
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com