quenio / ine5420 Goto Github PK
View Code? Open in Web Editor NEWComputer Graphics Discipline
Computer Graphics Discipline
Implement a Object3D class, which is comprised of a wireframe model of 3D vertices, and is able to perform the translation, scaling and rotation transformations.
Implement a new kind of Object in our model to represent Bézier Bicubic Surfaces.
We must implement curves as a new type of object in our world.
The first algorithm we should implement is the Bézier curve.
After selecting an object we want to be able to translate it to another position, using the arrow keys.
We must implement the Liang-Barsky clipping algorithm.
The points are being drawn as rectangles. We need to have a draw_circle primitive, so that we can draw the points.
After selecting an object we want to be able to rotate clockwise and counter-clockwise, using the left and right arrow keys.
Add. Rotate around the center of the world.
We need to update window rotation methods to use the normalized coordinate system from the viewport.
We need to implement the Cohen-Sutherland clipping algorithm.
We must implement methods to add and remove objects from the World and reflect the GUI accordingly.
When an object is selected on the list, its list of points should be displayed below the list of objects.
Add a label "Object" above the list of points, and a label "Points" above the list of points.
The ability to clip B-splines.
We must extend our Curve object to support B-Spline curves with as many control points as needed.
Each object should have one of the following states:
When rendering the objects, the visibility state must be verified so that:
Use the Window coordinate system to determine visibility state of each object.
We need to implement the Weiler-Atherton polygon clipping algorithm.
When the object is selected on the list, it should be drawn in red on the canvas.
After issue #62 has been merged to develop we're having some problems with CMake and GCC.
Scanning dependencies of target graphics
[ 50%] Building CXX object CMakeFiles/graphics.dir/main.cpp.o
c++: error: unrecognized command line option ‘-Weverything’
CMakeFiles/graphics.dir/build.make:62: recipe for target 'CMakeFiles/graphics.dir/main.cpp.o' failed
make[3]: *** [CMakeFiles/graphics.dir/main.cpp.o] Error 1
CMakeFiles/Makefile2:178: recipe for target 'CMakeFiles/graphics.dir/all' failed
make[2]: *** [CMakeFiles/graphics.dir/all] Error 2
CMakeFiles/Makefile2:190: recipe for target 'CMakeFiles/graphics.dir/rule' failed
make[1]: *** [CMakeFiles/graphics.dir/rule] Error 2
Makefile:157: recipe for target 'graphics' failed
make: *** [graphics] Error 2
We're using compiler specific parameters and this should be treated accordingly.
The 3D world currently can only show 3D objects. It should be able to display 2D objects as well.
The line clipping menu should have an option to disable clipping.
When line clipping, rotations get much slower than when clipping is disabled.
The Window should be displayed on the list of objects as the first/top item. When selected, the tools should manipulate the Window as if it was an object.
If the line's mid-point is out of the window bounds, the line won't be displayed.
Currently, the object visibility algorithm will check only the mid-point of a line to determine if the line is visible. It should instead use the clipping region codes.
Currently, you have to change the code to choose between Liang-Barsky and Cohen-Shuterland.
We need to add a Line-Clipping menu to allow switching between the methods at runtime.
The more you zoom into the window, the larger the point gets. The point's radius should be measured in world coordinates, and then translated to the canvas' coordinates.
We need to implement a basic matrix structure and its operations.
It will be used to implement all the object transformations in the world.
The ability to move the 3D objects on all axises.
Currently, the 3D object can only move on the XY plane.
We need to decouple the coordinates information from World Objects.
The screen's aspect ratio is causing distortion when rendering objects.
Implement perspective projection of 3D objects over the 2D Window.
We must take in consideration the 3D clipping methods.
Implement the projection of 3D objects over the 2D Window without taking into account perspective.
We need to update the window zooming methods to use the normalized coordinate system from the viewport.
The world window will have to be an object on the list, just like any other, and will need to have the same operations, translation, scaling, and rotation.
In order for that to work, we need to make Window extend Object.
As we inserted a new type of object in our world we must improve our clipping methods so that they work with curves.
The center of the Spline is not being calculated from its control points.
After selecting an object we want to be able to scale it up and down, using the up and down arrow keys.
We must implement a basic point clipping algorithm that will be used in case of emergencies and if the user chooses it.
Implement Coord3D, which has the x, y, and z coordinates, and is able to perform the translation, scaling, and rotation transformations.
We need to implement the normalized coordinate system for the world window and use it in the viewport transformation.
Refactor B-spline function to use TransformMatrix.
We need a small parser to read wavefront files and create our objects in the World.
More information about the file format can be found at wikipedia.
It is not possible to see on the canvas the control points that determine the shape of objects. This is specially a problem when trying to visually verify the shape of curves. The control points should be displayed when an object is selected.
We need to update the window translation to use the normalized coordinate system in the viewport.
It's important to consider the user perspective, so that if the window is rotated we must translate the window accordingly.
The underlying world model already allows multiple objects being selected, but there is no way to select multiple objects from the UI.
Today, we have a single Coord type for all coordinate systems: Window, Viewport and World.
We should have different Coord types for each coordinate system in order to make it clear the conversion required between them.
Implement viewport drawing limits in canvas.
Implement a new kind of Object in our model to represent Splines Bicubic Surfaces using forward differences.
Implement a new kind of Object in our model to represent Splines Bicubic Surfaces.
To increase the error reports and static analysis.
The point transformation methods - used in the Point, Line, Polygon and Window objects - are calculating the transformations again for every point. Instead, a list of points should be passed into these transformation methods, and the transformation matrix should be calculated once and reused for every point.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.