1. Programming in SRGP

2. INTRO Advantages of Raster Displays
Fill areas with uniform color or repeated pattern with 2 or more colors.
Stores images which allows fine level : individual pixels can be read or written and arbitrary portions can be copied or moved.

3. SRGP(Simple Raster Graphics Package)
Device independent Graphics package
Similar to Macintosh QuickDraw Raster package and Xlib package of Windows system

4. SRGP (Continued..) Drawing with SRGP Basic Interaction Handling
Raster Graphics Features
Limitations of SRGP

5. 1.Drawing with SRGP 1.1 Specification of Graphics Primitives
1.2 Attributes
1.3 Filled primitives and attributes
1.4 Saving and Restoring Attributes
1.5Text

6. 1.1 Specification of Graphics Primitives
Drawing in integer graphics package such as SRGP is like plotting graphs on graph paper with very fine grid
Grid varies from points per inch to 300 or more on high resolution displays
(0,0)--> bottom left of the screen . +ve x increases towards right and +ve Y increases towards top

7. 1.1 continued... SRGP supports basic collections of primitives Lines
Polygons
Circles
Ellipses
Text

8. Lines and Poly lines
Void SRGP_lineCoord(int x1, int y1, int x2, int y2);
eg:
SRGP_lineCoord(0,0,100,300)
(or)
void SRGP_line(point pt1,point pt2);
Point is a defined type, a record holding 2 integer x,y values
typedef struct
{int x,y;
}point;

9. Lines and Poly lines
A sequence of lines connecting successive vertices is called polyline.
There are 2 polyline procedures. These take array as parameter.
Void SRGP_polyLineCoord (int vertexcount,
int*xArray, int*yArray);
Void SRGP_polyLine(int vertexcount, point
*vertices);

10. continued.. /* plot the axes*/ SRGP_lineCoord(175,200,320,200);
/*plot the data*/
SRGP_polyLineCoord (12 ,months, balanceOfTrade);
SRGP_polyLine(7, bowtieArray);

11. contiued.. Markers and polymarkers
It is convenient to place markers(dots,asterisks or circles) at the data points on graphs.
Void SRGP_markerCoord(intx,inty);
Void SRGP_marker(point pt)
Void SRGP_polyMarkerCoord (int vertexcount, int*xArray, int*yArray);
Void SRGP_polyMarker(int vertexcount, point *vertices);

12. continued... Polygons and Rectangles
--> To draw an outline polygon, we can either specify a polyline on itself by making the first and last vertices identical (or) we can use
void SRGP_polygon(int vertexCount, point *vertices)
Now bowtieArray is of only 6 points it automatically closes the figure.

13. Continued
Any rectangle can be specified as a polygon having 4 vertices.
Uses only 2 primitives(lower left & upper right)
Void SRGP_rectangleCoord(int leftx, intbottomY,int rightX, int topY);
Void SRGP_rectanglePt(point bottomLeft, point topRight);
void SRGP_rectangle(rectangle rect);
typedef struct{ point bottomLeft,topRight;
}rectangle;

14. Rectangles continued.. Point SRGP_defPoint(intx,int y);
Rectangle SRGP_defRectangle(int leftX,int bottomY,int rightX, int topY);

15. Circles and Ellipses Circles are Special types of ellipses.
The term ellipse arc used for circular,elliptical,closed or partial arcs.
It is easy to specify arcs via upright rectangles (bounding boxes or extents)
Void SRGP_ellipseArc(rectangle extentRect, float startAngle, float endAngle);

16. Circles and ellipses
Relationship between rectangular and circular angle is
Rectangular angle=arctan(tan(circularangle).width/height)+
adjust
where the angles are in radians and
adjust = 0, for 0<= circular angle<∏/2
adjust = ∏/2 , for ∏/2 <=circular angle < 3∏/2
adjust = 2∏, for 3∏/2<= circular angle < 2∏

17. 1.2 Attributes
The specification of a primitive can be controlled by specification of its attributes
Line style and Line width
Color
Penstyle
Attributes are global state variables that retain their values until they are changed explicitly
Void SRGP_setLineStyle(lineStyle CONTINUOUS / DASHED /DOTTED/….);
Void SRGP_setLineWidth(int widthValue);

18. Attributes..
Each attribute has a default.. Eg., default for linestyle is CONTINUOUS that for line width is 1.
Line style can be represented as bit mask and it is scan converted by SRGP.
For eg.. Contimuous all 1’s
DASHED …..

19. Attributes for marker primitive
Void SRGP_setMarkerSize(int sizeValue);
Void SRGP_setMarkerStyle(markerStyle MARKER_CIRCLE / MARKER_SQUARE/…);
The default is circle style
COLOR
bilevel system the color value is 0 and 1.
-1 black, 0 white for black on white devices
1 green, 0 black for green on black devices

20. Attribute-color
The integer color attribute is an index to SRGP;s color table. Each entry defines color or gray scale value.
There are 2d entries and d is the depth of frame buffer
2 methods to specify colors
1. use integers 0 and 1 directly
2. use color names supported by SRGP
We can also select color by calling
Void SRGP_setColor(int colorIndex)

21. 1.3 Filled Primitives and Their Attributes
Primitives can be drawn in 2 ways
Outline
Filled
SRGP’s filled versions of area defining primitives draw the interior pixels with no outline

22. Code for creating filled Primitives

23. Output for the previous code

24. Odd Parity rule
We need a rule for specifying which regions are interior, and thus should be filled and which is exterior
This can done in SRGP through odd parity rule.
To check whether the region lies inside/ outside
Choose a test point
Choose a ray that starts at the test point extends indefinitely in any direction and does not pass any vertices.
If this ray intersect the polygon outline an odd no of times ->interior
else exterior

25. Fill style and fill pattern for areas
4 ways
Void SRGP_setFillStyle(drawStyle SOLID/ BITMAP_PATTERN_OPAQUE / BITMAP_PATTERN_TRANSPARENT/ PIXMAP_PATTERN);
There is no distinction in opaque & transparent in pix map patterns

26. Application screen background
Background color  0 bits in bitmap patterns used in opaque mode.
Suppose user expects the uniform screen background pattern then the application should set up the background in desired pattern. Default solid color 0
Erase primitive  is done by redraw them in the application background pattern.(Quick & dirty technique). This yield damaged image if primitives overlaps.
Damage repair is done by respecifying primitives in application data

27. 1.4 Saving and restoring Attributes
Attributes can be saved for later restoration.
It does not affect the global attribute state.
SRGP does this attribute group via
void SRGP_inquireAttributes(attributeGroup * group);
void SRGP_setAttributes(attributeGroup * group);

28. 1.5 Text
Specifying and implementing text drawing is always complex in graphics package. (style,font,bold,italic,width,spacing)
In SRGP text is horizontally aligned and character widths vary, but space b/w characters is constant.
High quality documents need specialized packages that offer more ctrl.
Eg. Post script
Text in SRGP is generated by
void SRGP_text(point origin, char *text);

29. 1.5 Text continued..
The location of text is ctrlled by specification of its origin/Anchor point
Text primitive’s appearance is determined by only 2 attributes (color and font)
void SRGP_setFont(int valueIndex)
Each character in the font is defined as rectangular bitmap.
SRGP draws a character by filling a rectangle using character bitmap as pattern in transparent mode.

30. Formatting text
Void SRGP_inquireTextExtent(Char*text, int *width, int * height, int *descent);

31. Code for formatting text

32. 2.Basic Interaction Handling
Topics to be discussed
Human Factors
Logical Input Devices
Sampling versus Event driven Processing
Sample mode
Event mode
Pick correlation for Interaction Handling
Setting Device Measure and Attributes

33. 2.1 Human Factors Interaction style(look and feel)
Ease of learning and use
Guidelines for user computer interaction
Provide simple and Consistent interaction sequence
Do not overload the user with too many different options
Show the available options clearly
Give appropriate feedback
Allow the user ti recover gracefully from mistakes.
1.Menus and palettes satisfy first 3 guidelines
2.Feedback every step by highlight the menu choice/echo eg. Text appears immediately in the cursor position as keyboard input is typed or movement of cursor appears when we move mouse position.
3.Graceful recovery is provided with cancel and undo/redo features

34. 2.2 Logical Input Devices Device types in SRGP
2 logical input devices supported by SRGP
a) Locator
b) Keyboard
SRGP maps the logical devices to physical devices(eg locator to mouse, joystick, tablet….)
SRGP provides only one logical locator and one keyboard device

35. 2.3 Sampling versus Event driven Processing
2 techniques to receive info created by User Interactions
Sampling(Polling)
Interrupt/Event driven
Sampling
AP queries the current value(measure) of logical device and continues exe.
By continuous sampling the change in the device state is known to application.
Demerit costly bcoz most of the CPU cycles waiting for measure change.

36. 2.3 Interrupt/ Event driven
Application enable 1 or more device and continue exe until interrupt by some i/p event(asynchronous ctrl transfer)
For each i/p event trigger is defined.
SRGP offers synchronous event driven mechanism
Application enable devices & continue exe…In background the package monitors the devices and stores info in the event queue.
Appln checks the queue at its convenience and process the events.
Event trigger user action that causes an event to occur. Eg button push , mouse click

37. 2.3 interrupt / Event driven
Queue contains one or more event ,wait state is desired.
Queue is empty, wait state not desired
Queue is empty, and wait state is desired
Difference b/w sampling and Event driven
Sampling event measure is collected regardless of any user activity, not efficient as cpu time is wasted for sampling loops.
Event Respond only when the user acts. More efficient using wait queue.

38. Sampling vs event driven
Think time

39. 2.4 Sample mode Activate,deactivate and seting mode of a device
Void SRGP_setInputMode(InputDevice LOCATOR/KEYBOARD, inputMode INACTIVE/SAMPLE/EVENT)
Locators measure  no of buttons that most recently experienced a transition
By default keyboard is operated in event mode.

40. 2.5 Event Mode SRGP_wait event
inputDevice SRGP_waitEvent(int maxWaitTime)
The fn returns immediately if queue is empty.
Negative maxtime(INDEFINITE)
The function returns the identity of the device

41. Event mode-Keyboard Trigger event of keyboard based on processing mode
1. EDIT mode->return key
2. RAW mode->every key
void SRGP_setKeyboardProcessingMode (keyboardMode EDIT/RAW)
Measure in RAW mode is one character length and in edit mode the measure is the string appears at the time of trigger

42. Event mode-locator
Trigger event is press or release of a mouse button.
Application tells SRGP which buttons are trigger a locator by
void SRGP_setLocatorButtonMask(int active buttons)
Values of button mask are LEFT_BUTTON_MASK, MIDDLE_BUTTON_MASK & RIGHT_BUTTON_MASK

43. 2.6 pick correlation for interaction Handling
Screen is divided into regions.
User presses the locator button the application determine exactly what screen button,icon or other object is selected and respond. (detemination is called pick correlation)
GEOM_ptInRect ( ) is a boolean fn

44. 2.6 High level interaction scheme for menu handling

45. 2.7 Setting Device measure and Attributes
Attributes can be any time, whether or nor the device is active.
Unlike attributes the measure is reset to a default value when the device is deactivated.
1.Locator echo attributes (DEFAULT is cursor)
void SRGP-setLocatorEchoType( echoType NO_ECHO/CURSOR/RUBBERLINE/RUBBERRECT)
2 .Locator measure control (default position is center)

46. 2.7 Setting Device measure and Attributes
3.Keyboard attributes and measure control
No screen position for keyboard so the position is thus an attribute of keyboard is set via
void SRGP_setKeyboardEchoOrigin(point origin)
Default measure for keyboard is automatically reset to null string. The keyboard measure is set via
void SRGP_setKeyboardMeasure(char *measure)

47. Raster Graphics Features
Canvases
Clipping Rectangles
SRGP_copypixel operation
Write mode or RasterOp

48. 2.3.1 Canvas
canvas
An area of memory which is used as a buffer between graphics software and graphics hardware.
SRGP canvas is a data structure that stores an image as a 2D array of pixels with some ctrl info(size and attributes of image)
Move Offscreen canvas to screen canvas to made visible using SRGP_copyPixel().
Properties (associated pixmap,coordinate system and attribute group) of canvas are called state/context of canvas.
New offscreen canvas can be created by
int SRGP_createCanvas(int width, int height);
Once canvas is created its size cannot be changed

49. 2.3.1 Canvas Void SRGP_useCanvas(int canvasID)
Void SRGP_deleteCanvas(int canvasID)

50. 2.3.2 clipping Rectangles
Clipping- The restriction of rendering to a designated area.
Clip rectangle attribute can be changed at any time and its most recent settings is stored.
void SRGP_setClipRectangle(rectangle clipRect)
rectangle SRGP_inquireClipRectangle();
Eg Ms word

51. 2.3.3 SRGP_copyPixel operation
Often called bitBlt (bit block transfer) / PixBlt
This command is used to copy an array of pixels from a rectangular region of a canvas(source region) to current active canvas(destination region)
void SRGP_copyPixel(int sourceCanvasID, rectangle sourceRect, point destCorner)

52. 2.3.4 Write Mode or RasterOp
CopyPixel can also execute logical operation. It can be symbolized as
D S op D
Op is called RasterOp /Write Mode consists of 16 Boolean operators.
Eg replace, or, xor , and
void SRGP_setWriteMode(writeMode WRITE_REPLACE/WRITE_XOR/WRITE_OR/WRITE_AND);
RasterOps are performed on pixels values.

53. 2.3.4 WriteMode continue..
Replace mode can be used to erase.

54. 2.4 Limitations of SRGP
No support for displaying 3D geometry applications.
Integer coordinate system of SRGP is too inflexible for appln require greater precision, range.
It stores images in canvas as a matrix of unconnected pixels rather than primitives so doesnot support delete, move or change.
As it doesnot keeps record of actions, refresh a screen or re-scan convert to display on device with diff resolution.