67 vues

Transféré par Harley Schenck

test

- ac3dfileformat
- Introduction to Maya
- assignmentQuestion (sem120172018)
- 4.12 - Defining Characteristics of Polygons
- Chapter 10
- Sacred Geometry Introductory Tutorial by Bruce Rawles
- Programming
- Oracle Map Viewer
- Hidden Line Removal
- 10.1.1.381.3003
- An Improvement of Lamport Clocks
- Lab Exercise 7_Lists
- DataStruct
- Project-w14.pdf
- Meljun Cortes Algorithm Funda of Algorithm
- /* Write a C Program to Illustrate the Operations Of
- LabTest_17181QUESTION-space (1).docx
- Numerical Methods Project Template
- Linked List ppt
- list.ppt

Vous êtes sur la page 1sur 5

ERICH L. FOSTER

BCAM - Basque Center for Applied Mathematics

efoster@bcamath.org

and

JAMES R. OVERFELT

Computer Science Research Institute - Sandia National Labs

Polygon clipping is a frequent operation in Computer Graphics, GIS, and

CAD. In fact, clipping algorithms are said to be one of the most important

operations in computer graphics [Schettino 1999; Agoston 2005]. Thus, ef-

ﬁcient and general polygon clipping algorithms are of great importance.

Greiner et al [Greiner and Hormann 1998] developed a time efﬁcient al-

gorithm which could clip arbitrary polygons, including concave and self

intersecting polygons. However, the Greiner-Hormann algorithm does not

properly handle degenerate cases, without the undesirable need for perturb-

ing vertices [Kim and Kim 2006]. We present an extension to the Greiner-

Hormann polygon clipping algorithm which properly deals with degenerate

cases. We combine the method proposed by Kim et al [Kim and Kim 2006]

and the method mentioned by Liu et al [Liu et al. 2007] to remove or prop-

erly label degenerate cases. Additionally, the algorithm presented avoids the

need for calculating midpoints, doesn’t require additional entry/exit ﬂags,

and avoids changing the vertex data structure used in the original Greiner-

Hormann algorithm, all of which are required by the extension presented by

Kim et al [Kim and Kim 2006].

Categories and Subject Descriptors: I.3.3 [Computer Graphics]: Pic-

ture/Image GenerationDisplay Algorithms; I.3.5 [Computer Graphics]:

Computational Geometry and Object Modelling

General Terms: Clipping, Polygon Comparison

Additional Key Words and Phrases: Degeneracies

ACM Reference Format:

Erich L. Foster and James R. Overfelt. 2013. Clipping of Arbitrary Poly-

gons with Degeneracies. ACM Trans. Graph. 5 pages.

DOI:http://dx.doi.org/10.1145/XXXXXXX.YYYYYYY

Authors’ addresses: Erich L Foster, efoster@bcamath.org, James R. Over-

felt, jroverf@sandia.gov

Permission to make digital or hard copies of part or all of this work for

personal or classroom use is granted without fee provided that copies are

not made or distributed for proﬁt or commercial advantage and that copies

show this notice on the ﬁrst page or initial screen of a display along with

the full citation. Copyrights for components of this work owned by others

than ACM must be honored. Abstracting with credit is permitted. To copy

otherwise, to republish, to post on servers, to redistribute to lists, or to use

any component of this work in other works requires prior speciﬁc permis-

sion and/or a fee. Permissions may be requested from Publications Dept.,

ACM, Inc., 2 Penn Plaza, Suite 701, New York, NY 10121-0701 USA, fax

+1 (212) 869-0481, or permissions@acm.org.

c YYYY ACM 0730-0301/YYYY/13-ARTXXX $15.00

DOI:http://dx.doi.org/10.1145/XXXXXXX.YYYYYYY

1. INTRODUCTION

Polygon clipping is an indispensable tool in computer graphics,

computer aided design (CAD) [Greiner and Hormann 1998; Kim

and Kim 2006], geographic information systems (GIS) [Liu et al.

2007], and for conservative interpolation for numerical simulation

[Farrell et al. 2009]. In the case of graphics and numerical simula-

tion, polygon clipping may need to be done thousands of times, and

in GIS the polygons that are to be clipped are generally non-convex

[Schettino 1999] and therefore efﬁcient and general algorithms for

polygon clipping are important.

Greiner et al [Greiner and Hormann 1998] developed a sim-

ple efﬁcient algorithm that could deal with non- convex and self-

intersecting polygons. The advantage of the Greiner-Hormann al-

gorithm lies in its simplicity, generality, and as compared to the

Vatti algorithm, its speed [de Berg et al. 2008]. Liu et al was able to

improve the memory efﬁciency of the original Greiner-Hormann al-

gorithm by maintaining a single doubly linked list of intersections,

instead of placing intersections in both polygons [Liu et al. 2007].

While the memory efﬁciency given by this method is certainly

important for many applications we are not concerned with this

improvement and therefore will only discuss the original Greiner-

Hormann algorithm. While the Greiner-Hormann algorithm has ad-

vantages over similar algorithms it does suffers from degenerate

cases. Greiner et al suggested a perturbation of these degeneracies

[Greiner and Hormann 1998; Liu et al. 2007]. However, this leads

to undesirable effects such as different solutions for different per-

turbation directions [Kim and Kim 2006].

In the sections that followwe present an extension to the Greiner-

Hormann algorithm for clipping arbitrary 2D polygons with degen-

eracies. The Greiner-Hormann algorithm has been lauded as hav-

ing the simplest data structure and outperforming similar polygon

clipping algorithms such as Vatti [Kim and Kim 2006; de Berg

et al. 2008]. However, there is one serious ﬂaw in the Greiner-

Hormann algorithm: degenerate case. Greiner et al suggested per-

turbing polygon vertices to deal with degenerate cases, but as

demonstrated by Kim et al this is undesirable due to the fact that

the resultant clipping is highly dependent upon the perturbation

direction, thereby making the algorithm indeterminate [Kim and

Kim 2006]. Kim et al presented their own extension to the Greiner-

Hormann algorithm that deals with these degenerate cases with-

out the need for perturbing polygon vertices. However, the method

requires calculating midpoints for certain degeneracies. In what

follows, we present an algorithm which combines the method de-

veloped by Kim et al [Kim and Kim 2006] and a method of re-

moving intersection mentioned by Liu et al [Liu et al. 2007]. This

method, as compared to the Kim et al method, avoids additional

entry/exit ﬂags, changing the original vertex data structure used in

the Greiner-Hormann algorithm, and the calculation of midpoints.

ACM Transactions on Graphics, Vol. VV, No. N, Article XXX, Publication date: Month YYYY.

2

•

E. L. Foster and J. R. Overfelt

v e r t e x = {

r e a l x , y ; / ∗ c o o r d i n a t e s ∗/

v e r t e x ∗ next , ∗ pr ev ; / ∗ l i n k p o i n t e r s ∗/

bool i s e c t ; / ∗ i n t e r s e c t i o n ∗/

bool en ; / ∗ e n t r y or e x i t ∗/

v e r t e x ∗ ne i ghbor ; / ∗ p o i n t e r t o

i n t e r s e c t i o n i n

a dj a c e n t pol ygon ∗/

v e r t e x ∗ ne xt Pol y / ∗ p o i n t e r t o head of

ne x t pol ygon ∗/

}

Fig. 1: Vertex Data Structure

The calculation of midpoints can be complicated when dealing with

spherical polygons.

Additionally, the extension we present does not require any ad-

ditions to the original traversal algorithm used by the Greiner-

Hormann. However, the time efﬁciency is hampered by requiring

that all intersections be evaluated for labeling, whereas the original

Greiner-Hormann algorithm only required the ﬁrst intersection be

evaluated for labeling and then all subsequent labels were set by

toggling the previous label.

2. GREINER-HORMANN

For completeness we present the original algorithm described by

Greiner et al. using a simple example. The Greiner-Hormann algo-

rithm consists of three phases: (1) Compute points of intersection

between the subject polygon, S, and the constraint polygon, C;

(2) Set traversal ﬂags at the intersections; (3) Traverse the polygons

adding vertices or intersections, to the clipped polygon, as they are

encountered.

In the Greiner-Hormann algorithm polygons are presented as cir-

cular doubly linked lists, where each node represents a vertex or

an intersection. Each vertex intersection is represented by a ver-

tex data structure, see Figure 1. Subject and constraint polygons

are linked through intersections by a neighbor pointer. This neigh-

bor pointer points to the corresponding intersection in the neigh-

bor polygon. To differentiate between intersections and vertices, a

boolean ﬂag, isect, is set to True for intersections and False for

vertices. Additionally, intersections use a boolean ﬂag, en, to indi-

cate if an intersection is an entry, True, or an exit, False. The same

boolean ﬂag is used for vertices to indicate if the vertex is inside,

True, or outside, False, of the neighbor polygon. It is this en ﬂag

and the neighbor pointer that are the crux of the Greiner-Hormann

algorithm, and tells one which direction to travel on the polygon

and allows for switching between polygons.

We will not discuss the ﬁrst phase in the Greiner-Hormann al-

gorithm, intersections, since this has been covered extensively by

others and may differ depending upon the setting, e.g. spherical

polygons [de Berg et al. 2008; ?]. However, the second phase,

which deals with labeling intersections, is of great importance and

is where our extension of Greiner-Horman will differ. Greiner et al.

traverses each polygon once, marking each vertex as an entry, en,

or an exit, ex. Initially, one traverses a given polygon until the ﬁrst

intersection is encountered, at this point the intersection is deter-

mined to either be an entry or an exit to the neighbor polygon and

label as such. One then continues to traverse the given polygon until

another intersection is encountered, labeling it the opposite of the

previous intersection, i.e. ex if the previous intersection was an en

C

S

C \ S

Fig. 3: Example of perturbation method and varying results depending on

direction of perturbation.

and en if the previous intersection was an ex. Once all intersections

have been labelled we proceed to the third phase.

The third phase of the Greiner-Hormann algorithm deals with the

traversal and building of the clipped polygon. To begin the traversal

of the clipped polygon one begins at the ﬁrst vertex of the subject

polygon and traverse it until an intersection is encountered; this

intersection is subsequently added to the clipped polygon. Traver-

sal direction is then determined by the entry/exit ﬂag of the corre-

sponding intersection; if the intersection is an entry one proceeds

forward along the subject polygon, but if the intersection is an exit

one proceeds in the backward direction along the subject polygon.

While traversing a polygon all vertices are added to the clipped

polygon. Once a new intersection is encountered it is added to the

clipped polygon and one switches, using the neighbor pointer, to

the adjacent polygon. Again, direction of traversal on the adjacent

polygon is determined by the entry/exit ﬂag. This procedure is re-

peated until one reaches the ﬁrst vertex of the clipped polygon. The

overall procedure is continued, creating new clipped polygons as

needed, until all intersections are consumeed. A demonstration of

the Greiner-Hormann algorithm including the traversal process can

be seen in Figure 2.

3. DEGENERACIES

In Section 2 we assumed there were no degenerate cases, i.e. cases

where a vertex lies on the edge of the neighbor polygon. Greiner

et al suggested perturbing these vertices to resolve degeneracies

[Greiner and Hormann 1998; Liu et al. 2007]. The problem with

this method of perturbation is clear and was even demonstrated in

Figure 12 of [Greiner and Hormann 1998]; the method of perturba-

tion can result in different solutions depending upon the direction of

perturbation, i.e. perturbing to the outside or inside of the neighbor

polygon (see Figure 3) [Kim and Kim 2006]. The differing results

means this method is indeterminate and not appropriate for various

applications, such as numerical simulation [Farrell et al. 2009].

ACM Transactions on Graphics, Vol. VV, No. N, Article XXX, Publication date: Month YYYY.

Clipping of Arbitrary Polygons with Degeneracies

•

3

S1

S2

S3

C1

C2

C3

C4

I1

I2

I3

I4

I5

I6

(a) Edge tracing of clipping process.

S1 I1

en

I2

ex

I3

en

S2 I4

ex

S3 I5

en

I6

ex

C1 I6

en

I1

ex

C2 I2

en

I4

ex

C3 C4 I3

en

I5

ex

next

prev

(b) Graphical representation of the clipping algorithm.

I1 I2 I4 S2 I3 I5 I6

(c) Clipped Polygon.

Fig. 2: Demonstration of the Greiner-Hormann Algorithm

Q2

Q1

P1

Case 1:

Q2

Q1

P1

Case 2:

Fig. 4: Degenerate cases

4. EXTENSION OF GREINER-HORMANN

ALGORITHM

In this section we discuss the extension of the Greiner-Hormann

algorithm by a combination of setting traversal ﬂags and remov-

ing unneeded/unwanted intersections. Greiner et al took advantage

of the entry/exit property, whereby intersections ﬂip between entry,

en, or exit, ex, as one moves from intersection to intersection. How-

ever, this assumption doesn’t always hold true. Unfortunately, this

is one of the properties of the Greiner-Hormann algorithm which

makes it efﬁcient, and therefore the dismissal of this assumption

will make the algorithm’s efﬁciency suffer. At the same time, it is

this assumption that results in a lack of robustness in the Greiner-

Hormann algorithm. So, while our extension is more robust it will

not be as efﬁcient as the original Greiner-Hormann algorithm.

The main difference in our method as compared to that used in

the original Greiner-Hormann method is that we do not make the

assumption that one can determine the entry/exit ﬂag of an intersec-

tion from the previous intersection. In fact, we use the location (in-

side/outside/on) of the previous and next vertex in the polygon data

type to determine the entry/exit property of an intersection. The in-

side/outside/on property can be determined using a ray casting al-

gorithm such as the one presented by Hormann et al [Hormann and

Agathos 2001]. Additionally, our method differs from the method

used by Kim et al in that we do not introduce any new entry/exit

ﬂags (i.e. ex/en, en/ex), the vertex data structure from the Greiner-

Hormann algorithm remains unchanged, we do not require the cal-

culation of midpoints to determine ﬂags, and the starting location

of the traversal (i.e. the initial intersection of the clipped polygon)

does not matter. Thus, our extension of the Greiner-Hormann al-

gorithm only requires a change in the vertex labeling phase of the

original algorithm, and doesn’t change the other phases. Thus the

implementation of our extension only requires recoding the label-

ing phase.

As in the standard Greiner-Hormann algorithm, polygons are

clipped in three stages; (1) compute intersections between the sub-

ject and constraint polygons, (2) set traversal ﬂags of intersections

and remove appropriate intersections if needed, (3) traverse the

polygons switching between polygons at intersections and adding

vertices/intersections, to the clipped polygon, as they are encoun-

tered.

4.1 Intersections

The process of adding intersections is unchanged from the Greiner-

Hormann algorithm, and, again, we will not discuss the method of

ﬁnding these intersections since the method may be differ from sit-

uation to situation and has been discussed extensively by others

[de Berg et al. 2008; Kim and Kim 2006]. However, recall from

the original Greiner-Hormann algorithm that once an intersection is

discovered it is added to the subject and constraint polygon. Also,

recall that each intersection is connected to its corresponding in-

ACM Transactions on Graphics, Vol. VV, No. N, Article XXX, Publication date: Month YYYY.

4

•

E. L. Foster and J. R. Overfelt

S1

S2

I1

C2

C3

I4

I5 I6

I2 I3

Remove intersection

and label out/in

en/ex ex/en en/ex

Remove intersection

and label in/in

ex/en

Fig. 5: Example of labeling/Removal process.

tersection in the neighbor polygon through the neighbor pointer. It

is this neighbor pointer which allows one to switch back and forth

between polygons.

4.2 Labelling/Removal of Intersections

The process of setting entry/exit ﬂags or removing intersection

ﬂags consists of: ﬁrst, cycling through the vertices of both the sub-

ject and constraint polygons and labeling them as inside or outside;

second, one cycles through the intersections of the subject polygon

labeling or removing intersections appropriately. One only needs

to traverse the subject polygon, since the same intersections exists

in both polygons and the intersection in the constraint polygon can

be accessed through the neighbor pointer. Once a label is set for

an intersection it is then required to check the (current,neighbor)

entry/exit pair before moving onto the next intersection, this way

a degenerate intersection does not affect the labeling of the next

intersection. An example of this process can be seen in Figure 5.

It should also be noted that all intersections are assumed to be ini-

tially set to en. This is necessary to prevent one intersection removal

from preventing a second intersection removal, which would occur

in Figure 3 if intersections were initially set to ex.

The previous and next pointers associated with an intersection

can be one of three cases: (1) on, the point is on the edge of the

neighbor polygon, i.e. is another intersection; (2) in, the point lies

within the neighbor polygon; (3) out, the point lies outside the

neighbor polygon. Therefore, there are a total of nine cases to deal

with when setting traversal ﬂags or removing intersection ﬂags. The

cases (in, out) and (out, in) are the original cases dealt with by the

Greiner-Hormann algorithm and their entry/exit ﬂag remains un-

changed, i.e. ex and en, respectively.

However, there are the degenerate cases that must also be dealt

with. For intersections, which have (prev,next) pairs (out,out),

(in,in), and (on,on) the action required is dependent upon the neigh-

bor’s pairing. If the neighbor also is of one of the three aforemen-

tioned cases, we will remove the intersection label, i.e. set isect to

False, since these do not add any new information to the traversal.

If the neighbor is not of these three cases the current intersection is

labelled either ex or en for (out,out) and (in,in) respectively. For the

case of (on,on) the intersection is labelled the opposite of its neigh-

bor, e.g. if the neighbor is (in,out) the current intersection would be

labelled en. In addition to the cases already mentioned, one must be

able to label cases where the (prev,next) pair consists of one on. In

the case of (on,out) or (in,on) the intersection is labelled ex, while

cases of (on,in) or (out,on) are labelled en.

Once a label is set, one must then check the (current,neighbor)

entry/exit ﬂag pair to ensure that one of the (en,en) or (ex,ex) cases

does not occur. If an (en,en) pair is encountered the intersection

prev / next on out in

on

1,2

ex en

out en ex

1,3

en

in ex ex en

1,4

Table I. : Action and label for each case.

1. Remove if neighbor is also one of the cases (on,on), (out,out), or (in,in).

2. Label opposite of neighbor if removed otherwise label in. 3. Label out if

removed. 4. Label in if removed.

current / neighbor ex en

ex remove and label out unchanged

en unchanged remove and label in

Table II. : Action after label has been set

ﬂag is removed and the vertex is set to in, on the other hand if an

(ex,ex) pair is encountered the intersection ﬂag is also removed, but

the vertex is labelled out. For the other two cases (en,ex) and (ex,en)

the intersection remains unchanged. For a summary of actions and

labels refer to Table I and Table II.

4.3 Clipping

The algorithm for traversal remains unchanged from the original

Greiner-Hormann algorithm and therefore no changes to the origi-

nal code is needed. Thus, when an intersection is encountered one

switches to the neighbor and proceeds forward for an en ﬂag and

backward for an ex ﬂag. The traversal is complete when one reaches

the initial clipped polygon vertex. This overall process is continued,

creating new clipped polygons as needed, until all intersections are

consumed.

It should be noted that for the example given in Figure 3, and

cases like it, all intersections would have been removed and one

would check to see if either polygon was completely contained

within the other. For the subject polygon, S, given in this exam-

ple, all vertices were also intersections, which would have been la-

belled as in when the intersection ﬂag was removed. Thus, looping

through vertices of the polygon, S, and checking if all vertices are

labelled as in is sufﬁcient for checking for a nested polygon.

5. CONCLUSIONS

We effectively dealt with degenerate cases, which was a limiting

factor for the use of the Greiner-Hormann algorithm. The intersec-

tion labeling technique employed is less efﬁcient than the original

method used by Greiner et al., however degenerate cases are no

longer a problem. By combining the methods developed by Kim et

al. and Liu et al. we are able to avoid, as compared to the Kim et

al. extension, adding additional entry/exit ﬂags, changing the ver-

tex data structure from the original Greiner-Hormann algorithm,

and calculating midpoints, which can be costly and complicated for

spherical polygons. Of course, the labeling method presented does

require checking neighbor intersection labels and possible subse-

quent removal of an intersection, which may be costly in its own

right, especially when polygons have many sides and many inter-

sections.

REFERENCES

M. Agoston. 2005. Clipping. In Computer Graphics and Geometric Mod-

eling. Springer London, 69–110.

ACM Transactions on Graphics, Vol. VV, No. N, Article XXX, Publication date: Month YYYY.

Clipping of Arbitrary Polygons with Degeneracies

•

5

M. de Berg, O. Cheong, M. van Kreveld, and M. Overmars. 2008. Com-

putational Geometry: Algorithms and Applications (3rd ed.). Springer

Berlin Heidelberg, Chapter 2, 19–43.

P.E. Farrell, M.D. Piggott, C.C. Pain, G.J. Gorman, and C.R.

Wilson. 2009. Conservative interpolation between unstructured

meshes via supermesh construction. Computer Methods in Ap-

plied Mechanics and Engineering 198, 3336 (2009), 2632 – 2642.

DOI:http://dx.doi.org/10.1016/j.cma.2009.03.004

G. Greiner and K. Hormann. 1998. Efﬁcient Clipping of Arbitrary Poly-

gons. ACM Trans. on Graphics 17, 2 (1998), 71–83.

K. Hormann and A. Agathos. 2001. The Point in Polygon Problem for

Arbitrary Polygons. Comp. Geometry 20 (2001), 131–144.

D. H. Kim and M.-J. Kim. 2006. An Extension of Polygon Clipping to

Resolve Degenerate Cases. Comp.-Aided Des. & Applic. 3, 1-4 (2006),

447–456.

Y. K. Liu, X. Q. Wang, S. Z. Bao, M. Gombosi, and B. Zalik. 2007. An

Algorithm for Polygon Clipping, and for Determining Polygon Intersec-

tions and Unions. Comp. & Geosci. 33 (2007), 589–598.

A. Schettino. 1999. Polygon Intersections in Spherical Topology: Applica-

tions to Plate tectonics. Comp. & Geosci. 25 (1999), 61–69.

ACM Transactions on Graphics, Vol. VV, No. N, Article XXX, Publication date: Month YYYY.

- ac3dfileformatTransféré parSteve Attwood
- Introduction to MayaTransféré parChaitanya Singumahanti
- assignmentQuestion (sem120172018)Transféré parHafiz Khairul
- 4.12 - Defining Characteristics of PolygonsTransféré parmrshong5b
- Chapter 10Transféré parmcblued
- Sacred Geometry Introductory Tutorial by Bruce RawlesTransféré parJustine Ong
- ProgrammingTransféré parAmimul Ihsan
- Oracle Map ViewerTransféré parPagada Vasthala
- Hidden Line RemovalTransféré pardhaval082
- 10.1.1.381.3003Transféré parcciatenutet
- An Improvement of Lamport ClocksTransféré parnachmanowicz
- Lab Exercise 7_ListsTransféré parहर्षा ihdowhodh
- DataStructTransféré pardearmohseen
- Project-w14.pdfTransféré parSamy Saad
- Meljun Cortes Algorithm Funda of AlgorithmTransféré parMELJUN CORTES, MBA,MPA
- /* Write a C Program to Illustrate the Operations OfTransféré parsangitsme
- LabTest_17181QUESTION-space (1).docxTransféré parizhar 6465
- Numerical Methods Project TemplateTransféré parMikaela Dela Cruz
- Linked List pptTransféré parKhali Pankaj
- list.pptTransféré parTahaRazvi

- FortiGate_200D_Series.pdfTransféré parPrakash Ray
- 2. Morphometric analysis and watershed development prioritization of.pdfTransféré parKuswantoro Al-ihsan
- Lab 1Transféré parashusparta
- CF-2Transféré parMuhammadFaisal
- internet.pptxTransféré parjay
- The Dying of LanguagesTransféré parDaisy
- DFD of Ford Purchasing SystemTransféré parAdam Ong
- Internationalization of manufacturing - Opportunities and threats for the Slovenian industry at the far EastTransféré pararmand.faganel9465
- Mechanotherapy: how physical therapists’ prescription of exercise promotes tissue repairTransféré parGiancarlo Gardella Martínez
- History to Read in the restTransféré parDilettante
- Emergence of Failed States in the International Legal OrderTransféré parshivam shantanu
- OpenWells Data SheetTransféré parJuan Flores Fernandez
- State Machines in JavaTransféré parcanrull
- March 2014 Grassroots East NewsletterTransféré partaylor8919
- change and future orientation theoryTransféré parapi-206475586
- Oracle Material-Dinesh.pdfTransféré paramitfegade121
- SQUID LOGTransféré parxuser
- Color Filter ArrayTransféré parMoji Piyapong
- Calendarizacion 2016 Final1 1 MadeTransféré parAnonymous 2xm3OW
- Looking for the Bouba-kiki Effect in Prelexical InfantsTransféré parYilbert Oswaldo Jimenez Cano
- The Coriolis ForceTransféré parAmy Capel
- Chapter 7Transféré parapi-3719928
- 02 ABPG2103 TOC (1)Transféré parUmmu Solihah
- hsv tipe 2Transféré parDyahSavitriKusumoningtyas
- analytical and historical school of jurisprudenceTransféré parNoel Panna
- ITSM ITIL Service Desk and Incident Management Product FlyerTransféré parAxiosSystems
- anr_6.33(63300007)_20171119_101032_1611174316Transféré parUsman T-ara
- TR Hilot (Wellness)Transféré parsss_sarzzz
- Paleolithic Nutrition Twenty-Five Years LaterTransféré parFrancesco Iavarone
- Maryam Jameelah Islam and Modern Man.pdfTransféré parSaad Ali