SUPER IMPORTANT SUMISSION GUIDELINES  You must include a makefile for each assignment!
 The makefile should invoke whatever is needed to compile and/or run your program.
 When I type
make , I expect to have your program generate and display an image.  If you cannot get the image to display (either programmatically or via the display command line program), then your program should print the name of the image file created.
 The image created should thoroughly test the assignment.
 Every assignment (unless otherwise noted) will require both a github submission and an image gallery submission. Full credit will require both.
 The gallery submission does not have to be the same as the test image generated when your code is tested.
 All github submissions should be submodules in the correct period directory for the assignment. Please see the resources page for help on linking your own repository as a submodule.
 You should maintain separate repositories for each assignment.
 Submodule naming schema:
 lastF_{0}f_{1}
 e.g. dyrlandweaverJo or konstantinovichSa or brooksPe
 When working with a partner
 lastF_{0}f_{1_}lastF_{0}f_{1}
 e.g. brooksPe_dyrlandweaverJo
 The first name should always be the earlier name alphabetically
 NEVER EVER EVER add image files to github
 Adding image files will result in deductions
 I will include a useful .gitignore file at the root of each assignment repository, if you want, copy it and rename it to .gitignore in your repo.
 Gallery submissions should be made here: http://gallery.stuycs.org

posted Apr 10, 2019, 7:00 AM by JonAlf DyrlandWeaver
Add scanline conversion and zbuffering to your graphics engine.  Parser Note:
 In the previous assignment, I noted that the clear command was no longer needed, because we immediately clear the polygon/edge matrix after a shape is drawn. In order to test Scanline conversion on multiple shapes, a different version of clear is useful. Now, clear will clear the screen and zbuffer, allowing us to reset and test multiple shapes in the same script.
 I have added this command to the provided source code, but everyone should implement it.
 Scanline conversion
 Create a new function that handles the scanline conversion.
 Call this in your draw_polygons function.
 Make sure that you change color values for each triangle.
 zbuffering
 In the base files provided, I've added a zbuffer argument to the necessary functions, but have not done anything with it.
 The zbuffer should only be modified in your plot function, or when clear_zbuffer is called.
 You will need to calculate z values in both scanline_convert and draw_line.
 Your z values are not limited to the integers.
GitHub repository: https://github.com/mks66/solids.git 
posted Apr 3, 2019, 6:33 AM by JonAlf DyrlandWeaver
[
updated Apr 4, 2019, 6:02 AM
]
(I do not know who or what the competition is)
Due: 8am Monday, 4/8
Note: If you are working in c, I have provided a basic stack library that you can use in the 66source repository
To implement a relative coordinate system... system, add/modify your current parser so it has the following behavior  push
 push a copy of the current top of the coordinate system (cs) stack onto the cs stack (a full copy, not just a reference to the current top... I'm looking at you python people)
 pop
 removes the top of the cs stack (nothing needs to be done with this data)
 move/rotate/scale
 create a translation/rotation/scale matrix
 multiply the current top of the cs stack by it
 The ordering of multiplication is important here.
 box/sphere/torus
 add a box/sphere/torus to a temporary polygon matrix
 multiply it by the current top of the cs stack
 draw it to the screen
 clear the polygon matrix
 line/curve/circle
 add a line to a temporary edge matrix
 multiply it by the current top
 draw it to the screen (note a line is not a solid, so avoid draw_polygons)
 save
 save the screen with the provided file name
 display
 Also note that the ident, apply and clear commands no longer have any use
github clone link: https://github.com/mks66/cstack.git 

posted Mar 21, 2019, 5:40 AM by JonAlf DyrlandWeaver
[
updated Mar 29, 2019, 6:50 AM
]
Work Due: 8 am Monday 4/1
You must do the following things:  Write correct, functioning code.
 Submit code that runs the provided testing script
 Upload an original picture to the gallery
The Drawing:  Create new functions to add a polygon to a matrix, and go through the matrix 3 points at a time to draw triangles.
 You should have a new triangle matrix that exists alongside the edge matrix. The edge matrix should be used for the shapes that are exclusively 2d (lines, circles, splines), and the triangle matrix for our 3d shapes.
 Anything aside from shape drawing that modifies/uses the edge matrix (apply, clear, display, save) should now modify/use the triangle matrix as well.
 Modify add box, add sphere and add torus to add triangles instead of points.
 Make sure the parser calls the draw_polygons functions when needed instead of draw_lines
 More to come...
 Vector math & Backface culling
 Implement the following vector functions
 Normalize a vector (provided as an array/list of 3 values)
 Find the dot product of 2 vectors (provided as arrays/lists of 3 values)
 Calculate the surface normal of a triangle in the polygon matrix (provided the polygon matrix and index.
 Check out gmath.h/c or gmath.py for headers and comments.
 Implement Backface culling.

Github clone link https://github.com/mks66/polygons.git 
posted Mar 15, 2019, 6:47 AM by JonAlf DyrlandWeaver
[
updated Mar 18, 2019, 7:27 AM
]
DUE: 8am Thursday 3/21
We will now begin to add 3d shapes (as points only) to our already simmering graphics stew.
You must do the following things:  Write correct, functioning code.
 Create a script file
 Upload a new picture to the gallery

 add the following commands to the parser
 clear: clears the edge matrix of all points
 c people: this is an incredibly simple operation that shouldn't involve futzing with any of the points in the edge matrix.
 box: adds a rectangular prism (box) to the edge matrix  takes 6 parameters (x, y, z, width, height, depth)
 sphere: adds a sphere to the edge matrix  takes 4 parameters (x, y, z, radius)
 torus: adds a torus to the edge matrix  takes 5 parameters (x, y, z, radius1, radius2)
 radius1 is the radius of the circle that makes up the torus
 radius2 is the full radius of the torus (the translation factor). You can think of this as the distance from the center of the torus to the center of any circular slice of the torus.
 To futureproof your code, you should split sphere/torus creation into 2 parts:
 Generating only the points on the surface of the shape.
 Adding the points to an edge matrix so that they can be drawn.
 Eventually, this part will be changed to handle solid shapes, but the points part will stay the same.
 You should actually add edges to draw the box.
 For the sphere and torus, just add the points for each point on the surface, and an edge from it to a point 1 pixel away to make it easier to see.

posted Mar 8, 2019, 6:51 AM by JonAlf DyrlandWeaver
[
updated Mar 12, 2019, 7:44 AM
]
DUE: 8am Wednesday, 3/13
It's time to add curves to the graphics engine. Everything will work as before, we will just have three more shapes to draw .
Add the following commands to the parser circle: adds a circle to the edge matrix  takes 4 parameters (cx, cy, cz, r)
 hermite: adds a hermite curve to the edge matrix  takes 8 parameters (x0, y0, x1, y1, rx0, ry0, rx1, ry1)
 The curve is between points (x0, y0) and (x1, y1).
 (rx0, ry0) and (rx1, ry1) are the rates of change at each endpoint
 bezier: adds a bezier curve to the edge matrix  takes 8 parameters (x0, y0, x1, y1, x2, y2, x3, y3)
 This curve is drawn between (x0, y0) and (x3, y3)
 (x1, y1) and (x2, y2) are the control points for the curve.
github clone link: https://github.com/mks66/curves.git 
posted Feb 26, 2019, 6:49 AM by JonAlf DyrlandWeaver
 Write code to work with transformation matrices:
 create a translation matrix
 create a scale matrix
 create a rotation matrix about the xaxis
 create a rotation matrix about the yaxis
 create a rotation matrix about the zaxis
 Note: The trig functions in python and c take radians as parameters, but you should assume degree input, make sure to convert or things won't look right.
 Modify your main routine so that it keeps track of:
 A single edge matrix
 A single master transformation matrix
 Create a parser that will interpret a script to be used to draw an image.
 Each command is a single word without spaces in it, and if it takes arguments, the line after will contain the arguments, separated by spaces. For example, a line of the file might look like this:
 Here is the full list of commands:
 line: add a line to the point matrix  takes 6 arguemnts (x0, y0, z0, x1, y1, z1)
 ident: set the transform matrix to the identity matrix
 scale: create a scale matrix, then multiply the transform matrix by the scale matrix  takes 3 arguments (sx, sy, sz)
 move: create a translation matrix, then multiply the transform matrix by the translation matrix  takes 3 arguments (tx, ty, tz)
 rotate: create a rotation matrix, then multiply the transform matrix by the rotation matrix  takes 2 arguments (axis theta)
 apply: apply the current transformation matrix to the edge matrix
 display: clear the screen, draw the lines of the point matrix to the screen, display the screen
 save: clear the screen, draw the lines of the point matrix to the screen/frame save the screen/frame to a file  takes 1 argument (file name)\
 The included script tests the various transformations, it should be used when I run make. You still need to create your own image and submit it to the gallery. Please include your script code only when you upload code to the gallery, this way it will be easy for others to try out your pictures!
github link: https://github.com/mks66/transform.git 
posted Feb 13, 2019, 6:50 AM by JonAlf DyrlandWeaver
[
updated Feb 15, 2019, 11:58 AM
]
This will be due Monday, 2/25
Implement the following features but you cannot trivialize the problem by using a structure that already exists in the language you choose:  General Matrix stuff
 matrix multiplication
 creation of an identity matrix
 displaying a matrix in a reasonable manner
 Graphics matrix stuff
 add a point to an edge matrix
 add an edge to an edge matrix (should call your add point routine)
 go through an edge matrix and draw the lines stored in the matrix (should call your draw line routine)
 Create a main function/method that demonstrates all the of matrix routines you wrote, and generates an image using the edge matrix structure. Upload the image to the gallery page.
READ THROUGH ALL THE SOURCE FILES. Detailed instructions are provided as comments.
Here is an example of output, including a correct matrix multiplication: Testing add_edge. Adding (1, 2, 3), (4, 5, 6) m2 =
1.00 4.00
2.00 5.00
3.00 6.00
1.00 1.00
Testing ident. m1 =
1.00 0.00 0.00 0.00
0.00 1.00 0.00 0.00
0.00 0.00 1.00 0.00
0.00 0.00 0.00 1.00
Testing Matrix mult. m1 * m2 =
1.00 4.00
2.00 5.00
3.00 6.00
1.00 1.00
Testing Matrix mult. m1 =
1.00 4.00 7.00 10.00
2.00 5.00 8.00 11.00
3.00 6.00 9.00 12.00
1.00 1.00 1.00 1.00
Testing Matrix mult. m1 * m2 =
40.00 76.00
47.00 92.00
54.00 108.00
7.00 16.00
github clone link: https://github.com/mks66/matrix.git 

posted Feb 6, 2019, 9:22 AM by JonAlf DyrlandWeaver
Due: Monday Morning (2/11)
You will write your own line algorithm!  First decide what you will be programming in for this assignment. You can use any language you'd like, but you must write your own line algorithm (do not use any built in function that may exist for your language of choice).
 Code Bresenham's line algorithm!
 Start with octant 1.
 Add the other octants one at a time, you'll have a much easier time debugging doing that.
 Trust me, I've done this a few times.
 Test your algorithm by calling your draw_line routine multiple times.
 Don't forget to upload an image to the gallery!
Follow these guidelines in your submission  Upload your code to gihub
 Upload an image to the gallery
 Include a makefile that will create an image using your code.
 Your code should result in displaying an image that tests all octants, including slopes of 0, 1, 1 and undefended.
 If you cannot run the display command, then save an image and print out the name of the image being saved.
 This image does not need to be the same as your gallery image.
If your are using my frameworks you only need to modify the following files: github clone link: https://github.com/mks66/line.git 
posted Jan 31, 2019, 7:02 AM by JonAlf DyrlandWeaver
Time for your first computer generated image:  Create a program that generates a valid ppm image file, it should be at least 500x500, but also don't make it too big (remember, each pixel is stored as up to 9 bytes  3 for each color value  so a 1000x1000 image could be 9MB large, they get big fast).
 Upload your code, as a submodule, to the appropriate place on github.
 Convert your image to a png and upload it to the ML6 gallery website: http://gallery.stuycs.org
 For help with converting, you should install ImageMagick
 on ubuntu,
aptget install imagemagick will work  on mac:
 First install XQuartz form here: https://www.xquartz.org/index.html
 (if you have homebrew installed):
brew install imagemagick withx11 will work ( the withx11 flag is very necessary, and I've already spent the hours yelling at the internet trying to figure out what was wrong.)  If you're more of a macports kind of person:
port install imagemagick
 on windows... installing ubuntu and running aptget install imagemagick will work (I've been told imagemagick works on cygwin)
 for more detailed instructions (including building and installing it on your own): http://www.imagemagick.org/script/binaryreleases.php
 You can also log into any stuy machine remotely, and run convert on them.
 Once you've installed image magic, you can convert with the following command:
convert <source> <destination> The destination format will be automatically set based on the file extension example: convert foo.ppm foo.png
 You must submit your code via github and upload an image!
 Did you remember to include a makefile?
github clone link: https://github.com/mks66/picmaker.git 


