void Task2::CreateParaline(float xvalue, float yvalue){
//make parallel line between points
Vector2f X1 = makeVector2f(startX1[0],(xvalue-scatterOrigin[0]));
Vector2f Y1 = makeVector2f(startX2[0],(yvalue-scatterOrigin[1]));
viewer->addLine( X1, Y1);
}
void Task2::DrawHyperbola(){
viewer->clear();
CreateAxis();
float u= minu;
//Create a hyperbola
for(int i=0; i < NumSamples; i++){
u = u + (maxu-minu)/NumSamples;
//Relative to the axis X
float pointX = (a * cosh(u));
float pointX2 = -(a * cosh(u));
float pointY =(b * sinh(u));
double rad = 45*3.1415926/180;
float newX = pointX * cos(rad) - pointY * sin(rad) +scatterOrigin[0];
float newX2 = pointX2 * cos(rad) - pointY * sin(rad)+scatterOrigin[0];
float newY = pointY * cos(rad) + pointX * sin(rad)+scatterOrigin[1];
float newY2 = pointY * cos(rad) + pointX2 * sin(rad)+scatterOrigin[1];
const Vector2f A = makeVector2f(newX,newY);
const Vector2f B= makeVector2f(newX2,newY2);
CreateParaline(newX,newY);
CreateParaline(newX2,newY2);
//Drawing the points on the screen
viewer->addPoint(A);
viewer->addPoint(B);
}
// display changes
viewer->refresh();
}
Task2::Task2()
{
viewer = NULL;
//scatterplot axis
scatterOrigin = makeVector2f(-1.5,0.0);
endAxisX = makeVector2f(12,0.0);
endAxisY = makeVector2f(-1.5,13.5);
endAxisYDown = makeVector2f(-1.5,-13.5);
endAxisXLeft= makeVector2f(-13.5,0.0);
//parallel cord axis
startX1 = makeVector2f(17.5,-13.5);
endX1 = makeVector2f(17.5,13.5);
startX2 = makeVector2f(20,-13.5);
endX2 = makeVector2f(20,13.5);
NumSamples = 10;
//slope values
slope = -1;
Yorigo = 13.5;
//circle values
Radius = 1;
Center = makeVector2f(0,0);
//hyperbola values
a = 1;
b = 1;
minu = -3;
maxu = 3;
}
void Experiment2D22::drawPlot() {
int rows = scaledData.size();
int cols = scaledData[0].size();
for (int i = 0;i < rows;i++)
{
for (int j = 0;j < cols-1;j++) {
viewer->addLine(makeVector2f(j*3,scaledData[i][j]),makeVector2f((j+1)*3,scaledData[i][j+1]), makeVector4f(1, 0, 0, 0.5));
}
}
}
void Experiment2D22::drawaxis() {
for (int i = 0;i < names.size();i++) {
Line parallelAxis;
parallelAxis.vertices[0] = viewer->addPoint(makeVector2f(i * 3, 0));
parallelAxis.vertices[1] = viewer->addPoint(makeVector2f(i * 3, 5));
viewer->addLine(makeVector2f(i * 3, 0), makeVector2f(i * 3, 5),makeVector4f(0.5, 0.5, 0.5, 0.5),5);
}
}
Experiment1_1::Experiment1_1() //Constructor
{
viewer = NULL; // Why?
start_point = makeVector2f(0,1);
line_slope = -1.0f;
line_len = 1.42f;
center = makeVector2f(4.0,4.0);
radius = 4.0f;
hyp_a=1.0f;
hyp_b=1.0f;
}
void Task2::DrawCircle(){
viewer->clear();
CreateAxis();
//Traslating the point of center to the right coordinate
float xCenter = Center[0]+scatterOrigin[0];
float yCenter = Center[1]+scatterOrigin[1];
//Create a circle by iterating over 360 degrees.
for(int i=1; i < NumSamples; i++){
float pointX = xCenter + Radius * cos(2 * 3.14159265 * float(i)/float(NumSamples-1));
float pointY = yCenter + Radius * sin(2 * 3.14159265 * float(i)/float(NumSamples-1));
//radiens not degrees
const Vector2f A = makeVector2f(pointX,pointY);
CreateParaline(pointX,pointY);
viewer->addPoint(A);
}
// display changes
viewer->refresh();
}
void AssignmentFour::magnitudeDistributionHelper(int n, float32 minX, float32 maxX, float32 minY, float32 maxY, vector<Vector2f> &points) {
float32 spread = (float32) (sqrt(n) * 1.2);
float32 dx = (maxX - minX) / spread;
float32 dy = (maxY - minY) / spread;
if (n <= 0) {
return;
}
vector< pair<float32, Vector2f> > magnitudes;
for (int xi = 0; xi < n; ++xi) {
for (int yi = 0; yi < n; ++yi) {
float32 x = minX + xi*dx;
float32 y = minY + yi*dy;
Vector2f v = makeVector2f(x, y);
float32 magnitude = getMagnitude(v);
magnitudes.push_back(make_pair(magnitude, v));
}
}
sort(magnitudes.begin(), magnitudes.end(), [](const pair<float32, Vector2f> &m1, const pair<float32, Vector2f> &m2) -> bool {
return m1.first > m2.first;
});
for (size_t i = 0; i < (size_t) n; ++i) {
points.push_back(magnitudes[i].second);
}
}
void Task2::NegativeSlope()
{
viewer->clear();
CreateAxis();
float pointX= scatterOrigin[0];
float pointY= Yorigo;
Vector4f color=makeVector4f(1,0,0,1);
int size= 5;
float pace=(endAxisX[0]-scatterOrigin[0])/NumSamples;
for(int i=0; i<=NumSamples; i++){
Vector2f scatterPoint= makeVector2f(pointX,pointY);
viewer->addPoint(scatterPoint);
CreateParaline(pointX, pointY);
pointX+= pace;
pointY= slope*(pointX-scatterOrigin[0])+Yorigo;
}
// display changes
viewer->refresh();
}
void Experiment1_1::DrawParallelPlot(float XSep)
{
float XOff=2.0; //Offset between the scatter plot and the parallel plot
//float XSep=5.0; //Separation between the axis of the parallel plot
for(int i=0;i<(int)Data.size();i++)
{
viewer->addLine(makeVector2f(XOff+max_Data[0],Data[i][0]-min_Data[0]+0.1+min_Data[1]), makeVector2f(XOff+max_Data[0]+XSep,Data[i][1]-min_Data[1]+0.1+min_Data[1]),makeVector4f(Data[i][0]/DataColorRange[0], Data[i][1]/DataColorRange[1], 0.5 /*((float) i)/Data.size()*/ , 1) );
}
//Axes
viewer->addLine(makeVector2f(XOff+max_Data[0],min_Data[1]), makeVector2f(XOff+max_Data[0],max_Data[0]-min_Data[0]+0.1+min_Data[1]), makeVector4f(1,0,1,1), 3);
viewer->addLine(makeVector2f(XOff+XSep+max_Data[0],min_Data[1]), makeVector2f(XOff+XSep+max_Data[0],max_Data[1]-min_Data[1]+0.1+min_Data[1]), makeVector4f(1,0,1,1), 3);
// display changes
viewer->refresh();
}
void Assignment5::Euler() {
//viewer->clear();
Vector2f seedPoint = makeVector2f(xStart,yStart);
Vector2f from = seedPoint;
Vector2f to;
for(int i = 0; i<nrStepsEuler; i++) {
to = from + makeVector2f((-from[1])*stepSizeEuler, (from[0]/2)*stepSizeEuler);
DrawLine(from, to, makeVector4f(0,0,1,1));
from = to;
}
viewer->refresh();
}
Vector2f normalToPolarCoords(const Vector3f &normal) {
if (normal[0] == 0.0f && normal[1] == 0.0f) {
if (normal[2] >= 0.0f)
return makeVector2f(0.0f, 0.0f);
else
return makeVector2f((float)M_PI, 0.0f);
} else {
Vector3f normDir = normal / norm(normal);
Vector3f planeDir = normDir; planeDir[2] = 0.0f;
float32 d = norm(planeDir);
Vector2f result;
result[0] = acos(normDir[2]);
result[1] = asin(planeDir[0]/d);
if (planeDir[1] < 0) {
result[1] = (float)M_PI - result[1];
}
if (result[1] < 0.0f) {
result[1]+= 2.0f*(float)M_PI;
}
return result;
}
}
void GeoXGLWidget3D::findClosestPoint(int x, int y)
{
int ind = -1;
double modelview[16], projection[16];
int viewport[4];
glGetDoublev( GL_PROJECTION_MATRIX, projection );
glGetDoublev( GL_MODELVIEW_MATRIX, modelview );
glGetIntegerv( GL_VIEWPORT, viewport );
double winX, winY, winZ;
for(int i = 0; i < (int)points.size(); i++)
{
gluProject(points[i].position[0],points[i].position[1],points[i].position[2],
modelview,projection,viewport,&winX,&winY,&winZ);
if((makeVector2f(winX,viewport[3]-winY)-makeVector2f(x,y)).getSqrNorm() < 16.0f)
{
if(points[i].canBeModified)
{
pickedPointIndex = i;
pickedZ = winZ;
break;
}
}
}
}
void Assignment5::Runge_Kutta() {
//viewer->clear();
Vector2f seedPoint = makeVector2f(xStart,yStart);
Vector2f from = seedPoint;
Vector2f to;
Vector2f v1;
float32 v2_x;
float32 v2_y;
Vector2f v2;
float32 v3_x;
float32 v3_y;
Vector2f v3;
float32 v4_x;
float32 v4_y;
Vector2f v4;
for(int i = 0; i<nrStepsRK; i++) {
// v1
v1 = makeVector2f(-from[1], from[0]/2);
// v2
v2_x = from[0] + (stepSizeRK/2)*v1[0];
v2_y = from[1] + (stepSizeRK/2)*v1[1];
v2 = makeVector2f(-v2_y, v2_x/2);
// v3
v3_x = from[0] + (stepSizeRK/2)*v2[0];
v3_y = from[1] + (stepSizeRK/2)*v2[1];
v3 = makeVector2f(-v3_y, v3_x/2);
// v4
v4_x = from[0] + stepSizeRK*v3[0];
v4_y = from[1] + stepSizeRK*v3[1];
v4 = makeVector2f(-v4_y, v4_x/2);
to = from + makeVector2f(stepSizeRK*((v1[0]/6)+(v2[0]/3)+(v3[0]/3)+(v4[0]/6)), stepSizeRK*((v1[1]/6)+(v2[1]/3)+(v3[1]/3)+(v4[1]/6)));
DrawLine(from, to, makeVector4f(1,0,0,1));
from = to;
}
viewer->refresh();
}
void Experiment1_1::DrawScatterPlot()
{
max_Data = makeVector2f(Data[0][0], Data[0][1]);
min_Data = makeVector2f(Data[0][0], Data[0][1]);
for(int i=0;i<(int)Data.size();i++)
{
if(i>0)
{
if (Data[i][0] > max_Data [0])
{
max_Data[0]=Data[i][0];
}
if (Data[i][1] > max_Data [1])
{
max_Data[1]=Data[i][1];
}
if (Data[i][0] < min_Data [0])
{
min_Data[0]=Data[i][0];
}
if (Data[i][1] < min_Data [1])
{
min_Data[1]=Data[i][1];
}
}
}
DataColorRange = makeVector2f(max_Data[0]-min_Data[0], max_Data[1]-min_Data[1]);
if (max_Data[0]<0)
max_Data[0]=0;
if (max_Data[1]<0)
max_Data[1]=0;
if (min_Data[0]>0)
min_Data[0]=0;
if (min_Data[1]>0)
min_Data[1]=0;
for(int i=0;i<(int)Data.size();i++)
{
Point2D NewPoint(Data[i][0], Data[i][1]);
NewPoint.color = makeVector4f(Data[i][0]/DataColorRange[0], Data[i][1]/DataColorRange[1], 0.5 /*((float) i)/Data.size()*/, 1);
viewer->addPoint(NewPoint);
}
//Axes
Point2D Origin(0, 0);
Origin.color = makeVector4f(1,1,1,1);
Origin.size = 10;
const int idOrigin = viewer->addPoint(Origin);
Point2D XNeg(min_Data[0], 0);
Point2D XPos(max_Data[0], 0);
XNeg.color = makeVector4f(1,0,0,1);
XPos.color = makeVector4f(1,0,0,1);
XNeg.size = 10;
XPos.size = 10;
const int idXNeg = viewer->addPoint(XNeg);
const int idXPos = viewer->addPoint(XPos);
Point2D YNeg(0, min_Data[1]);
Point2D YPos(0, max_Data[1]);
YPos.color = makeVector4f(0,1,0,1);
YNeg.color = makeVector4f(0,1,0,1);
YPos.size = 10;
YNeg.size = 10;
const int idYPos = viewer->addPoint(YNeg);
const int idYNeg = viewer->addPoint(YPos);
//X-Axis
Line Axis;
Axis.vertices[0] = idXNeg;
Axis.vertices[1] = idXPos;
Axis.color = makeVector4f(1,1,1,1);
Axis.thickness = 3;
viewer->addLine(Axis);
//Y-Axis
Axis.vertices[0] = idYNeg;
Axis.vertices[1] = idYPos;
viewer->addLine(Axis);
// display changes
viewer->refresh();
}
static Vector2f to(Vector2d p)
{
return makeVector2f(p[0], p[1]);
}
template<> Vector2f initVal<Vector2f>() { return makeVector2f(0.0, 0.0); }
Vector2f AssignmentFour::FieldValue(Vector2f xi) {
StaticVector<float, 2U> vec = Field.sample(xi[0], xi[1]);
Vector2f v = makeVector2f(vec[0], vec[1]);
if (DirectionFieldOnly) v.normalize();
return IntegrateBackwards ? -v : v;
}
Vector2f AssignmentFour::ExampleFieldValue(Vector2f vec) {
Vector2f v = makeVector2f(-vec[1], vec[0] / 2.0f);
return IntegrateBackwards ? -v : v;
}
void ExampleExperimentFields::DrawTexture()
{
viewer->clear();
//Load the texture using Qt
QImage image(ImageFilename.c_str());
//Get its (original) dimensions. Used as bounds later.
const float fWidth = (float)image.width();
const float fHeight = (float)image.height();
//Resize to power-of-two and mirror.
image = image.mirrored().scaled(NextPOT(image.width()), NextPOT(image.height()));
//Get its new integer dimensions.
const int iWidth = image.width();
const int iHeight = image.height();
if (bColoredTexture)
{
//Create three color channels for the texture
//Each of them is represented using a scalar field
ScalarField2 Red;
Red.init(makeVector2f(-fWidth, -fHeight), makeVector2f(fWidth, fHeight), makeVector2ui(iWidth, iHeight));
ScalarField2 Green;
Green.init(makeVector2f(-fWidth, -fHeight), makeVector2f(fWidth, fHeight), makeVector2ui(iWidth, iHeight));
ScalarField2 Blue;
Blue.init(makeVector2f(-fWidth, -fHeight), makeVector2f(fWidth, fHeight), makeVector2ui(iWidth, iHeight));
//Fill the scalar fields
for(size_t j=0; j<Red.dims()[1]; j++)
{
for(size_t i=0; i<Red.dims()[0]; i++)
{
Red.setNodeScalar(i, j, (float)(qRed(image.pixel(i, j))) / 255.0 );
Green.setNodeScalar(i, j, (float)(qGreen(image.pixel(i, j))) / 255.0 );
Blue.setNodeScalar(i, j, (float)(qBlue(image.pixel(i, j))) / 255.0 );
}
}
//Set the texture in the viewer
viewer->setTextureRGB(Red.getData(), Green.getData(), Blue.getData());
}
else
{
//Create one gray color channel represented as a scalar field
ScalarField2 Gray;
Gray.init(makeVector2f(-fWidth, -fHeight), makeVector2f(fWidth, fHeight), makeVector2ui(iWidth, iHeight));
//Set the values at the vertices
for(size_t j=0; j<Gray.dims()[1]; j++)
{
for(size_t i=0; i<Gray.dims()[0]; i++)
{
Gray.setNodeScalar(i, j, (float)(qGray(image.pixel(i, j))) / 255.0 );
}
}
//Set the texture in the viewer
viewer->setTextureGray(Gray.getData());
}
viewer->refresh();
}
void Experiment3_1::DrawIsoContour_Asymp()
{
viewer->clear();
//Load scalar field
ScalarField2 field;
if (!field.load(scalar_filename))
{
output << "Error loading field file " << scalar_filename << "\n";
return;
}
//Get the minimum/maximum value in that field
float32 min = std::numeric_limits<float32>::max();
float32 max = -std::numeric_limits<float32>::max();
for(size_t j=0; j<field.dims()[1]; j++)
{
for(size_t i=0; i< field.dims()[0]; i++)
{
const float32 val = field.nodeScalar(i,j);
min = val < min ? val : min;
max = val > max ? val : max;
}
}
//Plot the grid
//Traverse one dimension first and then the other dimension
for(size_t j=0; j<field.dims()[1]; j++)
{
viewer->addLine(field.nodePosition(0,j), field.nodePosition(field.dims()[0]-1,j), makeVector4f(0.5,0.5,0.5,grid_alpha), 1);
}
for(size_t i=0; i<field.dims()[0]; i++)
{
viewer->addLine(field.nodePosition(i,0), field.nodePosition(i,field.dims()[1]-1), makeVector4f(0.5,0.5,0.5,grid_alpha), 1);
}
//Optionally overlay data on the grid
if (grid_w_data == true )
{
//Draw a point for each grid vertex.
for(size_t j=0; j<field.dims()[1]; j++)
{
for(size_t i=0; i<field.dims()[0]; i++)
{
const float32 val = field.nodeScalar(i, j);
const float32 c = (val - min) / (max - min);
Point2D p;
p.position = field.nodePosition(i, j);
p.size = 5;
//Use a grayscale depending on the actual value
p.color[0] = c; p.color[1] = c; p.color[2] = c;
viewer->addPoint(p);
}
}
}
viewer->refresh();
//Plot the Iso Contour
//Traverse the cells
for(size_t i=0; i<field.dims()[0]-1; i++)
{
for(size_t j=0; j<field.dims()[1]-1; j++)
{
//Compute Max and Min values in each cell
float32 fval[4];
fval[0]= field.nodeScalar(i,j);
fval[1]= field.nodeScalar(i,j+1);
fval[2]= field.nodeScalar(i+1,j+1);
fval[3]= field.nodeScalar(i+1,j);
vector <Vector2f> Pos;
Pos.resize(4);
Pos[0]=field.nodePosition(i,j);
Pos[1]=field.nodePosition(i,j+1);
Pos[2]=field.nodePosition(i+1,j+1);
Pos[3]=field.nodePosition(i+1,j);
//output << "** "<< Pos[0][0] << " " << Pos[0][1] <<"\n";
//output << field.nodePosition(i,j)[0] << " "<< field.nodePosition(i,j)[1] << "\n" ;
float32 maxf, minf;
maxf=fmax(fval[0],fval[1]);
maxf=fmax(maxf,fval[2]);
maxf=fmax(maxf,fval[3]);
minf=fmin(fval[0],fval[1]);
minf=fmin(minf,fval[2]);
minf=fmin(minf,fval[3]);
//Check if the iso contour passes the grid
if((iso_c < minf) || (iso_c > maxf))
continue;
else //We plot the iso contour
{
float32 EdgeChar[3][4];
//Now figure out the signs for the four nodes
bool sign[4]= {0,0,0,0};
for(int k=0; k<4; k++)
{
if(fval[k]>=iso_c)
sign[k] = 1;
}
//Traverse the nodes clockwise and see if the edge carries a crossing point
for(int k=0; k<4; k++)
{
if( sign[k] ^ sign[(k+1)%4] )
{
EdgeChar[2][k] = 1;
float32 x,y;
x = ( (Pos[(k+1)%4][0] - Pos[k][0])*iso_c + Pos[k][0] * fval[(k+1)%4] - Pos[(k+1)%4][0] * fval[k] ) / ( fval[(k+1)%4] - fval[k] ) ;
y = ( (Pos[(k+1)%4][1] - Pos[k][1])*iso_c + Pos[k][1] * fval[(k+1)%4] - Pos[(k+1)%4][1] * fval[k] ) / ( fval[(k+1)%4] - fval[k] ) ;
EdgeChar[0][k] = x;
EdgeChar[1][k] = y;
}
else
EdgeChar[2][k] = 0;
}
//Count the number of edges that have a valid crossing point. It should be either 2 or 4
int EdgeCount=0;
for(int k=0; k<4; k++)
{
if(EdgeChar[2][k]==1)
EdgeCount++;
}
if(EdgeCount == 2)
{
//Simply plot the contour
vector <Vector2f> LineEnd;
LineEnd.clear();
LineEnd.resize(2);
int index=0;
for(int k=0; k<4; k++)
{
if(EdgeChar[2][k]==1)
{
LineEnd[index]= makeVector2f(EdgeChar[0][k], EdgeChar[1][k]) ;
index++;
}
}
viewer->addLine(LineEnd[0], LineEnd[1], makeVector4f(0.5,0.5,0.5,iso_alpha), 2);
viewer->refresh();
}
else //Cell has the contour intersecting at 4 points
{
//There is an ambiguity to be resolved
float32 fmid= (fval[3]*fval[1] - fval[2]*fval[0]) / ( fval[3]+fval[1] -fval[2] - fval[0] ) ;
vector <Vector2f> LineEnd;
LineEnd.clear();
LineEnd.resize(4);
for(int k=0; k<4; k++)
{
LineEnd[k]= makeVector2f(EdgeChar[0][k], EdgeChar[1][k]) ;
}
if(fval[1] < iso_c)
{
if(iso_c > fmid) //Connect 3 to 0 and 1 to 2
{
viewer->addLine(LineEnd[3], LineEnd[0], makeVector4f(1,0.5,0.5,iso_alpha), 2);
viewer->addLine(LineEnd[1], LineEnd[2], makeVector4f(1,0.5,0.5,iso_alpha), 2);
viewer->refresh();
}
else //Connect 0 to 1 and 2 to 3
{
viewer->addLine(LineEnd[0], LineEnd[1], makeVector4f(1,0.5,0.5,iso_alpha), 2);
viewer->addLine(LineEnd[2], LineEnd[3], makeVector4f(1,0.5,0.5,iso_alpha), 2);
viewer->refresh();
}
}
else
{
if(iso_c > fmid) //Connect 0 to 1 and 2 to 3
{
viewer->addLine(LineEnd[0], LineEnd[1], makeVector4f(1,0.5,0.5,iso_alpha), 2);
viewer->addLine(LineEnd[2], LineEnd[3], makeVector4f(1,0.5,0.5,iso_alpha), 2);
viewer->refresh();
}
else //Connect 3 to 0 and 1 to 2
{
viewer->addLine(LineEnd[3], LineEnd[0], makeVector4f(1,0.5,0.5,iso_alpha), 2);
viewer->addLine(LineEnd[1], LineEnd[2], makeVector4f(1,0.5,0.5,iso_alpha), 2);
viewer->refresh();
}
}
}
}
}
}
}
