Arc with radius between 2 points [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 3 months ago.
Improve this question
I need to find out how to draw an arc with OpenGL between 2 points with a given radius.Is there any way to do this in OpenGL or to find the center point where I need to draw the arc so the both points get connected with the given radius ? :)
Attached screenshot: https://i.imgur.com/LLP78Ak.png

Answer 1

Here is a simple, but complete and tested opengl program that demonstrates what it sounds like you are looking for. Note that there is not a single answer to the question of what is the arc between two points at radius x, since the arc can bend in either of two directions.
Pay careful attention to the second createArc function overload as this represents the core of the answer, though it calls the first createArc function overload to finish the job.
EDIT: I've realized that I did not account for the ambiguity of "arc between two angles" in my earlier answer (arc from 0 to 90 could be direct or all the way around). I've updated the code to define whether you are interested in the smaller arc or the larger arc.
#define GLEW_STATIC
#define _USE_MATH_DEFINES
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <gl/gl.h>
#include <math.h>
#include <iostream>
const int ARC_VERTEX_COUNT = 100;
// Don't use global variables at home, kids!
GLFWwindow* window;
GLuint shader;
GLint shaderLoc_pos;
GLuint vbo_circle;
GLuint vbo_arc;
float normalizeAngleToSmallestPositive(float angle) {
while (angle < 0.0) { angle += M_PI*2; }
while (angle >= M_PI*2) { angle -= M_PI*2; }
return angle;
}
bool startApp() {
if (!glfwInit()) {
return false;
}
window = glfwCreateWindow(500, 500, "Hello World", NULL, NULL);
if (!window) {
glfwTerminate();
return false;
}
glfwMakeContextCurrent(window);
glewInit();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLineWidth(10.0);
return true;
}
void stopApp() {
glfwTerminate();
}
void createShader() {
const char* vsSrc =
"#version 330 core\n"
"in vec2 pos; void main() { gl_Position = vec4(pos, 0.0, 1.0); }";
const char* fsSrc =
"#version 330 core\n"
"out vec4 color; void main() { color = vec4(1.0,1.0,1.0,0.5); }";
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, 1, &vsSrc, nullptr);
glCompileShader(vs);
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, 1, &fsSrc, nullptr);
glCompileShader(fs);
shader = glCreateProgram();
glAttachShader(shader, vs);
glAttachShader(shader, fs);
glLinkProgram(shader);
shaderLoc_pos = glGetAttribLocation(shader, "pos");
}
// Create an arc between two given angles, based on the circle described by the given radius and
// center point
GLuint createArc(float angle1, float angle2, float radius, float x, float y, float useBiggerArc) {
// Prepare angles
angle1 = normalizeAngleToSmallestPositive(angle1);
angle2 = normalizeAngleToSmallestPositive(angle2);
if (angle1 > angle2) {
float buffer = angle1;
angle1 = angle2;
angle2 = buffer;
}
if (useBiggerArc != angle2-angle1 > M_PI) {
angle1 += M_PI*2;
}
// Create opengl geometry
GLfloat pos[ARC_VERTEX_COUNT * 2];
for (int i = 0; i < ARC_VERTEX_COUNT; i++) {
pos[i*2] = sin((float)i / (ARC_VERTEX_COUNT-1) * (angle2 - angle1) + angle1) * radius + x;
pos[i*2+1] = cos((float)i / (ARC_VERTEX_COUNT-1) * (angle2 - angle1) + angle1) * radius + y;
}
GLuint result;
glGenBuffers(1, &result);
glBindBuffer(GL_ARRAY_BUFFER, result);
glBufferData(GL_ARRAY_BUFFER, sizeof(pos), pos, GL_STATIC_DRAW);
return result;
}
GLuint createCircle(float radius, float x, float y) {
return createArc(M_PI*0, M_PI*2, radius, x, y, true);
}
// Create an arc between two given points that is based on a circle with the given radius.
GLuint createArc(
float x1, float y1, float x2, float y2, float radius, bool arcDirection, bool useBiggerArc)
{
// distance between points
float distance = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
// halfway point
float xAverage = (x1+x2)/2.0;
float yAverage = (y1+y2)/2.0;
// circle center
float xCenter = sqrt(radius*radius - distance*distance/4.0) * (y1-y2) / distance;
float yCenter = sqrt(radius*radius - distance*distance/4.0) * (x2-x1) / distance;
xCenter = xAverage + (arcDirection ? xCenter : -xCenter);
yCenter = yAverage + (arcDirection ? yCenter : -yCenter);
// angles
float angle1 = atan2(x1-xCenter, y1-yCenter);
float angle2 = atan2(x2-xCenter, y2-yCenter);
// create the arc
return createArc(angle1, angle2, radius, xCenter, yCenter, useBiggerArc);
}
void runMainLoop() {
while (!glfwWindowShouldClose(window)) {
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(shader);
glEnableVertexAttribArray(shaderLoc_pos);
glBindBuffer(GL_ARRAY_BUFFER, vbo_circle);
glVertexAttribPointer(shaderLoc_pos, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDrawArrays(GL_LINE_STRIP, 0, ARC_VERTEX_COUNT);
glBindBuffer(GL_ARRAY_BUFFER, vbo_arc);
glVertexAttribPointer(shaderLoc_pos, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDrawArrays(GL_LINE_STRIP, 0, ARC_VERTEX_COUNT);
glfwSwapBuffers(window);
glfwPollEvents();
}
}
int main(void) {
if (startApp())
{
createShader();
vbo_circle = createCircle(0.75, 0.0, 0.0);
vbo_arc = createArc(0.0, 0.75, 0.75, 0.0, 0.75, false, false);
runMainLoop();
stopApp();
return 0;
}
else
{
return -1;
}
}

Answer 2

This is more of a maths question, I feel.
If you have the coordinates of the two points suppose:
and the given radius is 'R'
then the coordinates of the centre, say can be calculated using
where
,
there shall be two centres, one for an upward arc and another for a downward arc.
the other centre can be found through
now, you can find the inverse cosine using the acos() function included in the <cmath> library.