1.2K views

Uploaded by Amit Sangale

- Computer Graphics Practicals
- 37188108 Computer Graphics Lab Manual
- CG_LAB
- Computer Graphics Lab Programs
- IJAIEM-2014-10-31-98
- Efficient Skew Estimation and Correction for Doc Image
- Computer Graphics Practical Manual
- Computer Graphics MANUAL
- Leaf Severity Measurement Seminar
- IRJET-Bilingual Script Identification of Printed Text Image
- Cg Lab Manual
- Seismic Reservoir Characterization With Limited Well Control
- Literature Survey for 3d Reconstruction of Brain Mri
- Course Work Syllabus
- Chapter5 -Motion Detection, Segmentation and Wavelets
- UCLA Image Processing
- CIMST2013 ImageAnalysisIntro.pdf 755006104
- Submission of Electronic Artwork
- Unspervied Classification
- An Efficient Moving Object Detection Method under Illumination Changes

You are on page 1of 22

Title of Assignment:.

Assignments to understand functions available in graphics library such as,

a. Text and Graphics mode, initialization of graphics mode, graphics drivers,

switching between text and graphics mode, error handling.

b. Color, Color Palette, Aspect ratio, Text: fonts, alignment, size, orientation and

justification.

c. Graphics Primitives: Pixel, Line, Circle, Ellipse, Polygons, Line styles, Bar

graphs, Pie Charts, Histograms, filling a polygon, windowing.

Writing a Graphics Editor

Text Editor:

A text editor is a type of program used for editing plain text files.

Text editors are often provided with operating systems or software development

packages, and can be used to change configuration files and programming language

source code.

Graphics Editor :

A raster graphics editor is a computer program that allows users to paint and edit

pictures interactively on the computer screen and save them in one of many popular

"bitmap" or "raster" formats such as JPEG, PNG, GIF and TIFF.Usually an image viewer

is preferred over a raster graphics editor for viewing images.Some editors specialize in

the editing of photo-realistic images such as the popular Adobe Photoshop, while others

are more geared to artist-created illustrations.

First of all we have to call the initgraph function that will intialize the graphics mode

on the computer. initigraph have the following prototype.

void initgraph(int far *graphdriver, int far *graphmode, char far *pathtodriver);

Initgraph initializes the graphics system by loading a graphics driver from disk (or

validating a registered driver) then putting the system into

graphics mode.Initgraph also resets all graphics settings (color, palette, current

position, viewport, etc.) to their defaults, then resets graphresult to 0.

*graphdriver Integer that specifies the graphics driver to be used. You can give

graphdriver a value using a constant of the graphics_drivers enumeration type.

(unless *graphdriver = DETECT). If *graphdriver = DETECT, initgraph sets

*graphmode to the highest resolution available for the detected driver. You can give

*graphmode a value using a constant of the graphics_modes enumeration type.

*pathtodriver Specifies the directory path where initgraph looks for graphics drivers

(*.BGI) first.

2. If pathtodriver is null, the driver files must be in the current directory.

graphics_mode values or you'll get unpredictable results. (The exception is

graphdriver = DETECT.)

Graphics Primitives:

Point

form Scaled[ x, y ] or Scaled[ x, y, z ].

Points are rendered if possible as circular regions. Their diameters can be specified

using the graphics primitive PointSize.

Line

points.

Line can be used in both Graphics and Graphics3D (two- and three-dimensional

graphics).

The positions of points can be specified either in ordinary coordinates, as x, y or x, y,

z , or in scaled coordinates as Scaled[ x, y ] or Scaled[ x, y, z ].

Circle

centered at the point x, y.

Circle[ x, y , , ] yields an ellipse with semi-axes and .

Circle[ x, y , r, , ] represents a circular arc.

Circle[ x, y , , , , ] yields a segment of an ellipse obtained by transforming a

circular arc with the specified starting and ending angles.

Polygon

Polygon can be used in both Graphics and Graphics3D (two- and three-dimensional

graphics).

The positions of points can be specified either in ordinary coordinates as x, y or x, y,

z , or in scaled coordinates as Scaled[ x, y ] or Scaled[ x, y, z ].

The boundary of the polygon is formed by joining the last point you specify to the first

one.

Testing:

/* Sample program to draw a circle*/

#include<graphics.h>

#include<conio.h>

main()

{

int gd=DETECT,gm;

initgraph(&gd,&gm,""); /* initialization of graphic mode */

circle(150,150,100);

getch();

closegraph(); /* Restore orignal screen mode */

}

/* End of program */

Conclusion : Graphics initialization and different graphics functions are tested and used

successfully.

Assignment-2

Title of Assignment: Write a program to implement algorithm for DDA’s line

The program should make use of basic concept of DDA’s line generation algorithm.

DDA’s line generation algorithm:

The DDA is a scan conversion line algorithm based on calculating Dy and Dx. We

sample the line at unit intervals in one co-ordinate and determine corresponding integer

values nearest the line path for the other co-ordinate.

1. We will consider a line with positive slope. If the slope is less than or equal to 1,we

sample it at unit x intervals (Dx = 1) and compute each successive y value as

yk+1 = yk + m

Subscript k takes integer values starting from 1 for the first point and increases by 1 until

the final end point is reached. The value of m can be any real number between 0 and 1.

2. For lines with positive slope greater than 1, we reverse the roles of x and y. We

sample at unit y intervals and calculate each succeeding x value as

xk+1 = xk + 1/m

3. For the above equation we are processing the line equation from the left end point to

right end point. If this processing is reversed , so either we have

Dx = -1 and yk+1 = yk – m

Or

(Algorithm / Flow Chart / Pseudo Code / UML diagram / DFD as per

requirement)

Algorithm:

1. Input the two line endpoints and store the left endpoint in (xa,ya).

2. Plot the first point (xa,ya).

3. Calculate constants from the two end points such as Dx and Dy for horizontal

and vertical differences .

4. The difference with the greater magnitude determines the value of parameter

steps.

5. We determine the offset needed at each step to generate the next pixel position

along the line path.

6. We loop through this process steps times.

7. If the magnitude of Dx is greater than the magnitude of Dy and xa<xb, the values

of increments in the x and y directions are 1 and m respectively and if the

magnitude of Dx is greater than Dy and xa>xb , the values of decrements in the x

and y directions are -1 and –m respectively.

Void lineDDA (int xa , int ya , int xb , int yb)

{

int dx = xb – xa, dy = yb – ya , steps , k ;

Float xincr, yincr, x = xa ,y = ya;

If(abs(dx) > abs(dy)) steps = abs(dx);

xincr = dx / (float) steps;

yincr = dy / (float) steps;

Setpixel(ROUND(x),ROUND(y));

For(k=0; k<steps; k++)

{

x += xincrement;

y += yincrement;

Setpixel(ROUND(x),ROUND(y));

}

}

Testing:

Input :

Enter the starting point’s co-ordinates for line drawing.

200

200

Enter the ending point’s co-ordinates for line drawing

250

450

Output :

Assignment-3 (i)

Title of Assignment:. Write a program to draw a circle using Bresenhem’s circle algorithm.

The program should make use of basic concept of circle generation algorithm.

Bresenham’s circle generation algorithm:

This algorithm does only integer arithmetic which makes it faster than floating point. We are

creating only one octant i.e. from 90 to 45 degree.

We derive other seven octants of circle by symmetry property.

The circle is generated by considering center point as origin with radius ‘r’.The algorithm

calculates one new pixel per step.

Algorithm :

1. Accept radius and center co-ordinates from user and plot first point on circumference of

circle

(x,y) = (0.r)

2. Calculate the initial value of decision parameter S=3-2r

3. If we are using octant symmetry property to plot the pixel then until (x<y) we have to

perform following steps

If(S<=0)

Update S by S=S+4x+6 and increase x by 1

Else

and decrease y by 1

4. Determine the symmetry points in other octants also

5. Move and calculate the pixel position (x,y) on to the circular path .

Testing:

Input :

Enter the center co-ordinates for line drawing.

320

240

Enter the radius of a circle

150

Output:

Assignment-3 (ii)

Title of Assignment:. Write a program to draw a circle using Mid Point circle

Algorithm.

To apply the mid point method, we define a circle function:

Fcircle(x,y) = x2 + y2 – r2

1.Any point (x,y) on the boundary of the circle with radius satisfies the equation

fcircle(x,y) = 0.

2. If the point is in the interior of the circle ,the circle function is negative.

3. And if the point is outside the circle ,the circle function is positive.

5. We have to determine the next pixel position which is nearer to the circle either

(xk + 1,yk) or (xk +1,yk -1).

Pk = fcircle( xk +1,yk – ½)

8. The initial decision parameter is obtained by evaluating the circle function at the

start position (x0,y0)= (0,r)

9. p0 = 1-r.

Algorithm :

1.Input radius r and circle center (xc,yc) , and obtain the first point on the

circumference of the circle centered on the origin as

( x0,y0) = (0,r)

2. Caculate the initial value of the decision parameter as

P0 = 5/4 – r

3. At each xk position , startin at k =0,perform the following test : If pk < 0 , the

next point along the circle centered on (0,0) is (xk + 1,yk) and

Pk+1 = pk + 2xk+1 + 1

Otherwise , the next point along the circle is (xk +1,yk-1) and

5. Move each calculated pixel position (x,y) onto the circular path centered on

(xc,yc) and plot the coordinate values :

x= x + xc

y = y + yc

Testing: Input :

Enter the center co-ordinates for line drawing.

320

240

Enter the radius of a circle

150

Output :

Assignment-4

using scan-fill method.

In contrast to boundary fill and flood fill algorithm at pixel level, this algorithm is defined

at geometric level i.e. co-ordinates, edges, vertices etc.

This algorithm starts with first scan line and proceeds line by line toward the last scan line

and checks whether every pixel on that scan line satisfies our inside test or not, it checks

which points on that scan line are inside the polygon.

This method avoids the need for the seed point

Design Analysis / Implementation Logic:

(Algorithm / Flow Chart / Pseudo Code / UML diagram / DFD as per requirement)

Algorithm:

The following function fills the polygon with the scan fill :

Void polyfill :: scanline (int xx[10],int yy[10],int col,int n)

{

int i,k,int_x[50],temp,y,ymax=0,ymin=480;

float m[50],dx,dy;

for (i=0;i<n;i++)

{

if(yy[i]>=ymax) ymax=yy[i];

if(yy[i]>=ymin) ymin=yy[i];

dx=xx[i+1]-xx[i];

dy=yy[i+1]-yy[i];

if(dx==0) m[i]=0;

if(dy==0) m[i]=1;

if(dx!=0 && dy!=0)

m[i]=(float)dx/dy ;

}

int cnt;

for(y=ymax;y>=ymin;y--)

{

cnt=0;

for(i=0;i<n;i++)

{

if((yy[i]>y&&yy[i+1]<=y)||(yy[i]<=y&&yy[i+1]>y))

{

int_x[cnt]=(xx[i]+(m[i]*(y-yy[i])));

cnt++;

}

}

for(k=0;k<cnt-1;k++)

{

for(i=0;i<cnt-1;i++)

{

if(int_x[i]>int_x[i+1])

{

temp=int_x[i];

int_x[i]=int_x[i+1];

int_x[i+1=temp;

}

}

}

for(i=0;i<cnt-1;i+=2)

{

line(int_x[i],y,int_x[i+1]+1,y);

delay(10);

}

}

getch();

}

Testing:

Input : Draw a polygon with line drawing algorithm and enter the color to fill it.

Output : Displayed the result of scan fill operation. It fills the complete polygon with

specified color.

Conclusion : The polygon filling operations have been tested and executed successfully

Assignment-5

transformations.

Theory :

You define graphical objects in the Cartesian coordinate system by specifying the

coordinates of their vertices, which are the points at which the lines that make up the

object connect. For example, a triangle can be defined by three points, as shown in figure.

The defining points in the triangle are (2,5), (5,2), and (2,2).

Because of the differences between a screen display and the Cartesian coordinate system,

you need a way to translate points from one system to the other. In graphics terms, you

must map points in the Cartesian coordinate system to points in the screen coordinate

system so that objects you draw onscreen are positioned correctly. Forgetting about

negative coordinates for the time being, mapping point (x1,y1) in the Cartesian

coordinate system to point (x2,y2) in the screen coordinate system requires the following

simple formulas, shown in C++ program code

x2=y1;

y2=maxY-y1;

Because the X coordinate is unaffected by the mapping, x2 is simply assigned the value

of x1. To reverse the Y coordinate, the original Y coordinate is subtracted from the

window's maximum Y coordinate. For this formula to work, you must know the current

size of the window.

(I) Algorithm :

The first step in using matrices to transform a shape is to load the matrix with the

appropriate values. What values you use and where you place them in the matrix depend

on the type of transformations you're doing. A matrix that's set up to translate a shape

looks like this:

1 0 0

0 1 0

xTrans yTrans 1

Just like when you were using a formula to translate the vertices of a shape, in the

preceding matrix the xTrans and yTrans variables are the number of vertical and

horizontal units, respectively, that you want to translate the shape. In a program, you'd

initialize this matrix like this:

MATRIX3X3 m;

m[0][0] = 1.0; m[0][1] = 0.0; m[0][2] = 0.0;

m[1][0] = 0.0; m[1][1] = 1.0; m[1][2] = 0.0;

m[2][0] = xTrans; m[2][1] = yTrans; m[2][2] = 1.0;

xScaleFactor 0 0

0 yScaleFactor 0

0 0 1

Here, the variable xScaleFactor is how much you want to scale the shape horizontally,

whereas yScaleFactor is how much to scale vertically. In a program, you'd initialize the

scaling matrix like this:

MATRIX3X3 m;

m[0][0] = xScaleFactor; m[0][1] = 0.0; m[0][2] = 0.0;

m[1][0] = 0.0; m[1][1] = yScaleFactor; m[1][2] = 0.0;

m[2][0] = 0.0; m[2][1] = 0.0; m[2][2] = 1.0;

cos(radians) sin(radians) 0

-sin(radians) cos(radians) 0

0 0 1

Here, the variable radians is the angle of rotation in radians. In a program, you'd initialize

the rotation matrix like this:

MATRIX3X3 m;

m[0][0] = cos(radians);m[0][1] = sin(radians); m[0][2] 0.0;

0.0;

m[2][0] = 0.0; m[2][1] = 0.0; m[2][2] = 1.0;

MATRIX3X3& matrix1, MATRIX3X3& matrix2)

{

for (int x=0; x<3; ++x)

for (int y=0; y<3; ++y)

{

double sum = 0;

for (int z=0; z<3; ++z)

sum += matrix1[x][z] * matrix2[z][y];

product[x][y] = sum;

}

}

void InitMatrix(MATRIX3X3& m)

{

m[0][0]=1; m[0][1]=0; m[0][2]=0;

m[1][0]=0; m[1][1]=1; m[1][2]=0;

m[2][0]=0; m[2][1]=0; m[2][2]=1;

}

(III)Copying a Matrix

void CopyMatrix(MATRIX3X3& dst, MATRIX3X3& src)

{

for (int i=0; i<3; ++i)

for (int j=0; j<3; ++j)

dst[i][j] = src[i][j];

}

void Translate(MATRIX3X3& m, int xTrans, int yTrans)

{

MATRIX3X3 m1, m2;

m1[1][0]=0; m1[1][1]=1; m1[1][2]=0;

m1[2][0]=xTrans; m1[2][1]=yTrans; m1[2][2]=1;

MultMatrix(m2, m1, m);

CopyMatrix(m, m2);

}

void Scale(MATRIX3X3& m, double xScale, double yScale)

{

MATRIX3X3 m1, m2;

m1[1][0]=0; m1[1][1]=yScale; m1[1][2]=0;

m1[2][0]=0; m1[2][1]=0; m1[2][2]=1;

CopyMatrix(m, m2);

}

void Rotate(MATRIX3X3& m, int degrees)

{

MATRIX3X3 m1, m2;

if (degrees == 0) return;

double c = cos(radians);

double s = sin(radians);

m1[1][0]=-s; m1[1][1]=c; m1[1][2]=0;

m1[2][0]=0; m1[2][1]=0; m1[2][2]=1;

CopyMatrix(m, m2);

}

Testing:

Input: Draw any polygon shape and perform the transformation with specified factors.

MATRIX3X3 m;

InitMatrix(m);

Translate(m, 10, 15);

Scale(m, 0.5, 0.5);

Rotate(m, 45);

Transform(shape1, m);

DrawShape(shape1);

Output: The result of all the transformations is displayed with respective factors of

transformations.The code segment first declares a 3x3 transformation matrix called m. It

then calls InitMatrix() to initialize m to an identity matrix. At this point, m looks like this:

0.0000000000000 1.0000000000000 0.0000000000000

0.0000000000000 0.0000000000000 1.0000000000000

The call to Translate() composes m with a translation matrix containing the values 10 and

15, which leaves m containing the translation. The transformation matrix, m, now looks

like this:

0.0000000000000 1.0000000000000 0.0000000000000

10.000000000000 15.000000000000 1.0000000000000

After the call to Scale(), m contains the translation and scaling values:

0.0000000000000 0.5000000000000 0.0000000000000

10.000000000000 15.000000000000 1.0000000000000

scaling, and rotation—for the shape:

-0.35355339062953 0.35355339055702 0.0000000000000

10.000000000000 15.000000000000 1.0000000000000

The call to Transform() applies the translation matrix m to all of the

vertices in shape1, after which DrawShape() draws the newly transformed

shape onscreen

Conclusion : All transformation options stated above are tested and executed

successfully.

Assignment-6

Title of Assignment:. Write a program to implement the concept of segmentation.

Theory : Segmentation

Another way of extracting and representing information from an image is to group pixels

together into regions of similarity. This process is commonly called segmentation. In

2D

-- we would group pixels together according to the rate of change of their

intensity over a region.

3D

we group together pixels according to the rate of change of depth in the

image, corresponding to pixels lying on the same surface such as a plane,

cylinder, sphere etc.

Operations on segments:

Opening a segment

Once a display list is opened, you can create segments in it. A segment is a collection

of elements, which are either Starbase primitive calls, attribute calls, or control

functions. To open a segment, use the routine open_segment

where:

the end of the segment or to be left where it is. If 〈append〉 is FALSE, the

element pointer is left where it was when the segment was previously closed

(or at the null element if the segment hasn't been opened before); if

〈append〉 is TRUE, the element pointer is set to the last element in the

segment.

• Display: is a boolean that specifies whether or not the following graphics calls

are to be inserted into the display list, displayed, or both. If 〈display〉 is

DL_ONLY (or FALSE), the elements are merely inserted into the segment; if

〈display〉 is DL_AND_DISPLAY (or TRUE), any subsequent elements in the

segment are inserted into the segment and displayed on the display device; if

〈display〉 is DISPLAY_ONLY, any subsequent elements in the segment are

displayed on the display device but are not inserted into the segment.

Some things to be aware of when opening segments are as follows:

contents. Adding to a segment's contents is mentioned above: merely open a

segment and do some Starbase operations. Modifying (other than just adding

to) a segment, as well as inquiring a segment's contents, are discussed later.

• At any one time, there can only be one open segment per display list. If you

open a segment and then open another segment before explicitly closing the

first one, Display List closes the first segment before opening the second.

• When a segment is opened for the first time, an empty segment is created. In

other words, there is nothing special you need to do to "create" a segment

before you open it. If you open a segment that has not been referenced

before, Display List creates a new, empty segment, and then opens it.

Closing a segment :

close_segment(fildes);

There are no parameters such as append or display, because they are irrelevant to

the closing operation. There is no need even for a segment number: since only one

segment can be open at any one time, there can be no ambiguity as to which

segment you are specifying. If there are no segments currently open, close_segment

is a no-op.

Renaming a segment

The first time you open a Segment model, the segments and segment groups have

assigned names that are generic, such as Segment1, Segment2, and so on. These

generic names are listed in the Segment hierarchy. The entire population for all

segments is listed in the Segment hierarchy as Population (100%).

After you have examined a segment or segment group and determined which of its

characteristics are significant, by using the summary information for the segment

and comparing it to other segments, you can give it a more descriptive name. When

you choose a new name for a segment or segment group, you must choose a name

that is unique to the Segment model.

Testing:

Input : Segments for Ex alphabets from A to Z will be displayed and any segment to

make ON ( an alphabet ) will be entered.

Output : The segment which is inputted will be ON and highlighted with different color.

Conclusion : Segmentation is implemented successfully

- Computer Graphics PracticalsUploaded bySayyed Salman Mehdi Mosvi
- 37188108 Computer Graphics Lab ManualUploaded bypaviucet
- CG_LABUploaded byvathanaudhayan
- Computer Graphics Lab ProgramsUploaded byRahul Hellsanxel
- IJAIEM-2014-10-31-98Uploaded byAnonymous vQrJlEN
- Efficient Skew Estimation and Correction for Doc ImageUploaded byRoophini Nagarajan
- Computer Graphics Practical ManualUploaded byrajankur7
- Computer Graphics MANUALUploaded byAyush Khandelwal
- Leaf Severity Measurement SeminarUploaded bypgakare
- IRJET-Bilingual Script Identification of Printed Text ImageUploaded byIRJET Journal
- Cg Lab ManualUploaded byPurush Thaman
- Seismic Reservoir Characterization With Limited Well ControlUploaded byMahmoud Said
- Literature Survey for 3d Reconstruction of Brain MriUploaded byInternational Journal of Research in Engineering and Technology
- Course Work SyllabusUploaded bysufyan006
- Chapter5 -Motion Detection, Segmentation and WaveletsUploaded byAshwin Josiah Samuel
- UCLA Image ProcessingUploaded byDhruv Ramani
- CIMST2013 ImageAnalysisIntro.pdf 755006104Uploaded byPatil Jagadeesh Reddy
- Submission of Electronic ArtworkUploaded bySabri Taridala
- Unspervied ClassificationUploaded byPhearum Phann
- An Efficient Moving Object Detection Method under Illumination ChangesUploaded byseventhsensegroup
- OO Image Segm 10.1.1.18Uploaded byvestanbul
- Color- And Texture-Based Image Segmentation Using EMUploaded byGaurav Sharma
- 10.1.1.400.6229.pdfUploaded byYanquiel Mansfarroll Gonzalez
- IRJET-Fingertip Detection Method in Hand Gesture RecognitionUploaded byIRJET Journal
- 1-s2.0-S0730725X12002846-main.pdfUploaded byJosé Hernández
- cg_1Uploaded bypramod
- ICASSP_p3989-3992_t2008-4.pdfUploaded byRaviTeja
- Algorithm for segmentationUploaded byKeren Evangeline. I
- 02Uploaded byMegha Badad
- 5031 Principals of MultimediaUploaded byAnuraj Singh

- Computer Networks FAQsUploaded byAmit Sangale
- ADBMS Lab ManualUploaded byAmit Sangale
- Adbms Oral FaqUploaded byAmit Sangale
- PCD Final AssUploaded byAmit Sangale
- Adbms Oral Questions Topic - Client Server Architecture (Unit III).Uploaded byAmit Sangale
- OS Lab ManualUploaded byAmit Sangale
- Ommd QuestionUploaded byAmit Sangale
- 2008 09 OOMD Lab ManualUploaded byAmit Sangale
- Rdbms Vpl Lab ManualUploaded byAmit Sangale
- DSP LabmanualUploaded byAmit Sangale
- Unit i : Classification of SignalsUploaded byAmit Sangale
- Programming Laboratory Lab_manualUploaded byAmit Sangale
- Software LabUploaded byAmit Sangale
- Cnl Lab Manual FullUploaded byAmit Sangale
- Cg Oral QuestionUploaded byAmit Sangale
- Dsl Oral QuestionUploaded byAmit Sangale
- Mil Oral QuestionUploaded byAmit Sangale
- MIL Lab Manual NewUploaded byAmit Sangale
- Lab Manual OopsUploaded byAmit Sangale
- Lab Manual DslUploaded byAmit Sangale
- Unit 6 1. Which Are Different Techniques of Document IndexingUploaded byAmit Sangale
- Amit 1 What is .Diff Between Oltp n Olap(3 Pts)Uploaded byAmit Sangale
- Topic Name: Distributed Database System Q1:What Do You Mean ByUploaded byAmit Sangale
- Adbms Oral” Question “unit -1”Uploaded byAmit Sangale

- ch9Uploaded byguwei
- CoordinatesUploaded byyeghna_hager
- Robot Arm Control With Arduino 3Uploaded byRashmi Ranjan Rrs
- StaadUploaded byAya Montes
- TimeViz - Visualization of Time-Oriented DataUploaded byFinigan Joyce
- 4 Hyperbola HkUploaded byMichael Esteves Llona
- Technical Handbook.pdfUploaded byrecai
- Geometric Dimensioning and TolerancingUploaded byeizhar
- C3 January 2010Uploaded byAnonymous RnapGaSIZJ
- Studies on Ellipse EquationUploaded byhugocrony
- Java networking and awt bibleUploaded byapi-3774122
- Robo Guide BookUploaded byVenkateswar Reddy Mallepally
- ASCE7-05 Wind Wizard HandbookUploaded byphuongkq832
- OpenFoam TutorialsUploaded bykushvverma2003
- Asphalt Crack Classification Paper01Uploaded byhrababaa
- Calculus From Rice UniversityUploaded byΘωμαςΣτεφανιδης
- 3d-vision.pdfUploaded byatom tux
- KinematicsUploaded byHema Prasanth
- 4 AxisUploaded byCecep Devi Nugraha
- Sap 2Uploaded byAlex Chira
- Maho Dialog user manual D112 V3 02EUploaded bykratmel
- sample-chapter--ch02.pdfUploaded bySam Royce
- Applied Business AnalysisUploaded byCharles Johnson
- Doc 962 IX Maths Support Material and VBQ 2014 15Uploaded byVinod Kumar
- keyshaft factorsUploaded byGuilherme Henrique Faria Aires
- kjkjlUploaded bySivi Karudijan
- 10_Areas of Bounded Regions.pdfUploaded bythinkiit
- Bodum GlassUploaded bySahil Sharma
- LayoutsUploaded byatul_botre
- 11 Maths NcertSolutions Chapter 10 1Uploaded byShiva Krishna