代写program编程、C++程序代写

日期：2023-01-16 10:10

Computer Animation Technical Arts

THE BRIEF

This programming project assignment requires the design and implementation of a computer graphics

application supported by a report discussing its design and implementation (counting for 50% of unit

mark). It assesses software development practice, knowledge of procedural programming concepts as

well as understanding of basic 2D computer graphics techniques and algorithms. This is in relation to the

following ILO’s (Intended Learning Outcomes) of the Programming Principles Unit:

Being able to implement algorithms in general and basic CG algorithms using a suitable

Application Programming Interface (API).

Demonstrating an ability to design and implement suitable data structures.

Demonstrating an ability to apply suitable software engineering principles.

All assignments must be written in C (not C++) and make use of the SDL library (and appropriate SDL

extensions such as SDL_image or SDL_ttf) for creating windows, accessing images and pixel drawing

operations (as well as OpenGL for option 3) and must include a working “makefile” that will successfully

build the project on the lab machines (on Linux).

Project Option 1: Turtle Graphics & Drawing Spirolateral Curves

Turtle graphics (http://en.wikipedia.org/wiki/Turtle_graphics) is a simple and well know method for

drawing complex shapes from simple lines. Turtle graphics employs the concept of a “turtle”, which is a

simple robot or agent in the shape of a turtle that has the following attributes (usually implemented using

a record data structure):

a position (x, y) in 2D space,

a heading or angle measured in degrees or radians, and

a flag/variable pen that could be set either as Up (True/drawing) or as Down (False/not drawing)

If the turtle's pen is set to have the value Down and the turtle moves then the turtle leaves a trace

while it moves. It accepts the following simple instructions (usually implemented as functions):

pen_up sets the state of the turtle's pen to Up,

pen_down sets the state of the turtle's pen to Down,

move n makes the turtle move n units along its heading (usually implemented by drawing a line

segment between the start point and the end point), and

turn α turns the heading of the turtle by α degrees.

While there are some similarities between turtle graphics and L-systems, turtles and L-systems are not

the same and need to be treated/implemented differently.

A spirolateral is a geometric shape/pattern that is constructed from a series of straight lines of growing

length that are attached at an angle, which, if repeated after one another, will result in a closed curve

(http://mathworld.wolfram.com/Spirolateral.html).

Your task is to first implement a simple turtle library (data structure & a set of related functions – not

implemented as an L-system) using C in combination with the SDL library for 2D pixel drawing and then

to use this library to create a spirolateral drawing program with a simple user interface (that may be

graphical or text-based) that is capable of the following:

1. allow the user to interactively (through the user interface) select/change the drawing parameters

such as drawing and background colours, the initial length and number of line segments. These

parameters should also include the number of repetitions of the initial pattern, the drawing angle

etc.

2. provide a set of (at least) three pre-set spirolaterals that are selectable by the user for drawing

3. save the resulting spirolaterals as image files, and optionally save the spirolateral drawing as an

image sequence that shows the addition of each line segment as a separate (animation) frame

that would show the curve being drawn step by step

Recommended reading:

Krawczyk, R.J. (1999). “Spirolaterals, Complexity from Simplicity”, in Proceedings of the 1999

Conference of The International Society of the Arts, Mathematics and Architecture. Available

from: http://mypages.iit.edu/~krawczyk/isama99.pdf

Krawczyk, R.J. (2000). “The Art of Spirolaterals”, in Proceedings MOSAIC 2000, the Millennial

Open Symposium on the Arts and Interdisiciplinary Computing. Available from:

http://mypages.iit.edu/~krawczyk/mosaic00.pdf

Reed, D. (2002), “CSC 107, Lab 2: Functions and Turtle Graphics”, in Nifty Assignments –

SIGCSE 2002. Available from: http://dave-reed.com/Nifty/WalkLab.html

Project Option 2: Raster Graphics Editor (Paint Program)

Your task is to write a Raster Graphics Editor (https://en.wikipedia.org/wiki/Raster_graphics_editor) in

C/C++, i.e. a 2D computer graphics paint program for creating and manipulating bitmap images.

Your program should be able to load and save user-selected images and include a user interface (e.g.

buttons for selecting drawing operations – to simplify the user interface creation, buttons could be placed

into a separate window from the image drawing surface).

As a minimum the program should also include the following common operations for image editing:

1. allow the user to select the drawing colour

2. drawing on a window by placing individual (pixel) points or by using a brush (pre-defined pixel

combination) and filling an image area with the drawing colour (bucket-fill), as well as erasing

pixels from the image

3. drawing lines straight lines and pre-defined geometric shapes (filled and outlined boxes and

circles), ideally with “Rubber Banding”, which requires some creative frame-buffer/drawing

surface management (https://www.javatpoint.com/computer-graphics-elastic-or-rubber-band?techniques)

Recommended reading:

http://gigi.nullneuron.net/gigilabs/sdl2-pixel-drawing/

https://wiki.libsdl.org/CategoryMouse

Willis, P. (1984), “A paint program for the graphic arts in printing”, in Proceedings of the

European Graphics Conference and Exhibition, pp. 109-120. Available from:

https://researchportal.bath.ac.uk/en/publications/a-paint-program-for-the-graphic-arts-in-printing

Smith, A.R. (1997) “Digital Paint Systems - Historical Overview”, Technical Memo 14, Microsoft.

Available from: http://alvyray.com/Memos/CG/Microsoft/14_paint.pdf

Project Option 3: Breakout

Your task is to write a clone of the classic arcade video game “Breakout” (released in 1976), making use

of the OpenGL API in conjunction with the SDL library (see: https://en.wikipedia.org/wiki/Breakout_(video_game),

https://en.wikipedia.org/wiki/Arkanoid and https://www.youtube.com/watch?v=Up-a5x3coC0).

In the game Breakout, the player controls a horizontal paddle at the bottom of the screen that is used to

hit a bouncing ball towards a wall of bricks at the top of the screen, which get ‘destroyed’ when hit with

the ball (different types of bricks may need a different number of hits to break). The speed of the ball is

variable, depending on different factors (e.g. the ‘angle’ of connection with the paddle) If the player

misses the ball, i.e. if the ball falls below the bottom of the screen, the player loses a ‘life’.

As a minimum, your program should include the following features:

1. a keyboard-controlled paddle for the player and three player ‘lives’

2. two different types of brick and three different levels that show a different target-wall (hard-coded

or possibly loaded from a file)

3. at least one power-up (e.g. gained by hitting a certain number of bricks in a short time or a

special brick being destroyed etc.) that provides a bonus to the player (e.g. short-term slow-down

of the ball, a wider paddle, an extra ‘life’ etc.)

Recommended reading:

https://www.c64-wiki.com/wiki/Arkanoid

Project Option 4: Image Manipulation Application

Your task is to write an image manipulation (https://en.wikipedia.org/wiki/Digital_image_processing)

application tool in C/C++, i.e. a 2D computer graphics program for manipulating/modifying of bitmap

images.

Your program should be able to load and save user-selected images and include a user interface (e.g.

buttons for selecting image processing operations – to simplify the user interface creation, buttons could

be placed into a separate window from the image drawing surface). As a minimum the program should

also include the following common operations for image manipulation:

allow the user to select areas of images (e.g. rectangular areas) or whole images

allow the user to blur or sharpen selected areas of images

allow users to change the brightness, contrast and gamma and add glare of selected areas of

images

allow the user to use thresholding, grayscaling, image highlights and RGB colour filters on

selected areas of images

Do not hard-coded filenames of files that the user is supposed to manipulate (e.g. the filename for

images a user loads or saves)!

Recommended reading:

https://wiki.libsdl.org/CategoryMouse

https://web.archive.org/web/20170711021400/http://www.cs.umb.edu/~jreyes/csit114-fall-

2007/project4/filters.html

http://gigi.nullneuron.net/gigilabs/converting-an-image-to-grayscale-using-sdl2/

http://www.codeproject.com/Articles/33838/Image-Processing-using-C

Marking Criteria:

The quality of the source code and usability of the program. This includes effective use of

programming techniques, such as using structured and procedural programming, recursion,

relevant control structures and data structures, etc., but also encompasses adherence to the brief

(such as the use of the prescribed programming language and libraries). This will count for 50%

of the mark of your assignment.

The remaining 50% will be determined by:

The project report, including Background, Implementation, Results (see section 3 of the

submission details below) and references using BU Harvard referencing.

The (visual) Impact (i.e. how well it achieves the intended results) of the generated artefacts

(based on the Results section of your report, and/or submitted generated artefacts, see

submission details).

? Source code documentation (relevant and appropriate comments in the source code).