Another Simple but Faster Method for 2D Line Clipping

Dimitrios Matthes; Vasileios Drakopoulos

REVIEW 4 major objections 3 minor 30 references

Another Simple but Faster Method for 2D Line Clipping

T0 review · 4 major / 3 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read A simplified 2D line-clipping algorithm is faster than six established methods in benchmark tests.

desk verdict A clean, teachable KWC variant; the algorithm is plausible and even handles axis-aligned lines, but the 'better than all' speed claim rests on a benchmark that is too thin to believe as stated. read the letter →

arxiv 1908.01350 v1 pith:FBVTGSD2 submitted 2019-08-04 cs.GR cs.CG

Dimitrios Matthes , Vasileios Drakopoulos This is my paper · ORCID

classification cs.GRcs.CG

keywords lineclipping2DcomputergraphicsalgorithmrectangularwindowequationperformancebenchmarkCohen-SutherlandLiang-Barsky

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper introduces a new algorithm for clipping 2D line segments against an axis-aligned rectangular window. The method uses the two-point form of the line equation to compute intersection coordinates with the window boundaries directly, replacing only the endpoint coordinates that fall outside the window. In timed benchmarks with one million and ten million random lines, the authors report that the proposed algorithm is faster than six established line-clipping methods: Cohen-Sutherland, Liang-Barsky, Cyrus-Beck, Nicholl-Lee-Nicholl, Skala, and Kodituwakku-Wijeweera-Chamikara. The reported speedups range from about 6.8% over the fastest competitor to 27% over the slowest, and the paper argues the method is also simpler and uses fewer variables than existing approaches.

What carries the argument

The central object is the two-point form of the line equation, written as $y = y_1 + \frac{y_2-y_1}{x_2-x_1}(x-x_1)$ and $x = x_1 + \frac{x_2-x_1}{y_2-y_1}(y-y_1)$. The algorithm uses these identities to compute the intersection of the line with a window boundary: when a coordinate of an endpoint lies outside the window, that coordinate is replaced by the boundary value ($x_{min}$, $x_{max}$, $y_{min}$, or $y_{max}$) and the equation gives the matching other coordinate. This direct boundary-replacement step is what carries the argument, because it eliminates the region-encoding comparisons of Cohen-Sutherland, the parameter-interval solves of Liang-Barsky and Cyrus-Beck, and the many subcase branches of Nicholl-Lee-Nicholl. The proposed method also drops the dot and axis-parallel checks that the Kodituwakku-Wijeweera-Chamikara algorithm includes, relying on a preliminary same-side rejection test and a final inside test to decide what to draw.

What would settle it

Run the published pseudocode on a vertical line, such as $x_1 = x_2$, or a horizontal line, such as $y_1 = y_2$, against a window that partially overlaps the line; the Step 2 expressions $(y_2-y_1)/(x_2-x_1)$ or $(x_2-x_1)/(y_2-y_1)$ divide by zero, so the algorithm will crash or produce undefined output.

Watch

Extended reading notes

Core claim

The paper's central claim is that its new line-clipping algorithm outperforms six established methods in speed and simplicity for the classic task of clipping a line segment against a rectangle. The algorithm first rejects lines whose two endpoints lie on the same side of the window. For each endpoint that crosses a boundary, it sets the offending coordinate to the boundary value and solves the two-point line equation for the other coordinate, producing the clipped endpoint in one step. The same procedure is applied to both endpoints, and a final test verifies the result before the line is drawn. Experiments in C++ with OpenGL on 1,000,000 and 10,000,000 random lines show the proposed method with the lowest average execution time among all seven algorithms tested; the margins range from 6.78% faster than Kodituwakku-Wijeweera-Chamikara to 26.95% faster than Cyrus-Beck on the smaller set, with similar margins on the larger set.

Load-bearing premise

The load-bearing premise is that the line is neither vertical nor horizontal, since the algorithm's Step 2 divides by $(x_2-x_1)$ and $(y_2-y_1)$ and the pseudocode removes the axis-parallel checks, so vertical or horizontal lines cause division by zero.

Editorial extensions

If this is right

If the reported timings are reproducible, the method gives a faster default for 2D line clipping in software rasterizers and interactive graphics.
Because it avoids bitwise region codes, the algorithm ports cleanly to languages like Scratch where Cohen-Sutherland's AND operations are difficult to implement.
The speed advantage persists when the workload grows from one million to ten million lines, suggesting the improvement is stable rather than a small-sample artifact.
The small number of variables and branches makes the method simpler to teach and to verify by hand in introductory computer graphics courses.
The authors note the approach may extend to 3D clipping, where the same boundary-replacement idea could replace the plane-intersection bookkeeping of 3D Liang-Barsky.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The benchmark uses a fixed screen-to-window size ratio and random lines with a uniform distribution in the drawing space; a different ratio or a biased distribution (for example, mostly axis-aligned lines) could change both the rejection rate and the ranking, since the proposed method has no early exit for axis-aligned segments.
The claimed speedups depend on the cost model of C++ floating-point division and comparison; on platforms with slow division or fixed-point arithmetic, the two division-heavy intersection formulas may erode the advantage over comparison-heavy alternatives.
A natural testable extension is to modify the algorithm to detect vertical and horizontal lines first and handle them with the trivial $x = x_1$ or $y = y_1$ intersection, then re-measure the speed against the same six baselines to see whether the guard costs more than the axis-parallel branch it replaces.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The paper is a small, clearly explained variant of the Kodituwakku-Wijeweera-Chamikara line-clipping algorithm. It drops some checks, shortens the code, and claims a few percent speedup. The novelty is modest but real, and the paper is honest about building on KWC. If you teach 2D clipping, this version is easy to present.

On the division-by-zero worry: the stress-test is right and the reader's concern doesn't land. Step 1 rejects horizontal lines entirely above/below and vertical lines entirely left/right before the divisions in Step 2 are reached. For axis-aligned lines that cross the window, the denominators are nonzero in the branch that executes, so the pseudocode is well-defined. I checked the edge cases and couldn't break it.

The real soft spot is the benchmark. One machine, 10 runs per condition, no error bars, no source code, no description of how the random lines were generated. The margin over the closest competitor is 6.8%, and individual runs overlap (see the 1M-line run 6). The abstract also promises an operation-count comparison, but no operation counts are tabulated. That's a significant gap between claim and evidence.

Minor issues: the formulas in Section 2.2 have a typo in the y-branches, writing (ymin - x1) and (ymax - x1) where it should be (ymin - y1) and (ymax - y1). The pseudocode is correct, so it's just a text slip. There is no correctness proof or test suite; a short proof or a few corner-case tests would settle the algorithm's correctness cleanly.

The citation pattern looks fine. The one self-citation is to the authors' Scratch extension paper, which is relevant and not a sign of padding.

Overall, this is a plausible minor contribution to a mature subfield. The speed claim is credible but not established. It deserves peer review, not a desk reject, because the algorithm is concrete and the weaknesses are fixable. A serious referee should ask for the code, a proper experimental protocol with more trials and a described workload distribution, and a correctness test. With those, the claim could become believable. As it stands, I would not accept it without major revision, and I would not cite it in my own work yet.

Recommendation: send it to review, but expect heavy revision.

Referee Report

4 major / 3 minor

Summary. The paper proposes a new 2D line-clipping algorithm against an axis-aligned rectangular window. The method tests four trivial rejection conditions first, then for each endpoint substitutes the window boundaries into the slope-intercept form of the line to compute clipped coordinates, and finally validates the new endpoints before drawing. The authors compare it with Cohen-Sutherland, Liang-Barsky, Cyrus-Beck, Nicholl-Lee-Nicholl, Skala, and Kodituwakku-Wijeweera-Chamikara, using wall-clock times for clipping and drawing 1,000,000 and 10,000,000 randomly generated lines in C++/OpenGL, averaged over ten runs per condition. They report that the proposed method is faster than all six competitors (for example, 6.78% faster than Kodituwakku-Wijeweera-Chamikara at 1M lines and 6.80% at 10M lines) and conclude that it is simpler, faster, and uses fewer operations and variables.

Significance. The proposed algorithm is very easy to describe and implement, which is genuinely useful for computer graphics education; the early trivial-rejection step is a sound design choice, and the number of variables appears small. If the speed advantage were established by a rigorous, reproducible benchmark, the paper would offer a practical alternative for workloads with many trivially rejected lines. However, the contribution is incremental: line clipping is a mature topic, the algorithm is closely related to Kodituwakku-Wijeweera-Chamikara with the parallel-line and dot checks removed, and the central 'better than all' claim currently rests on an underpowered, unreplicated benchmark. The paper credits no machine-checked proofs, releases no code, and provides no operation-count table, so the significance of the contribution will remain modest until the empirical evidence is strengthened.

major comments (4)

[Section 3, Tables 1 and 2] The reported statistics do not support the central speed claim. Ten runs per condition are summarized only by their average, with no standard deviation, confidence interval, or paired significance test. This is load-bearing for the decisive comparison against Kodituwakku-Wijeweera-Chamikara, the fastest competitor: the 1M-line averages differ by only 6.78%, and the individual runs overlap substantially (e.g., Table 1 shows KWC run 3 at 1.196 s versus proposed runs 6 and 8 at 1.216 s and 1.209 s). A paired test on the raw run data, or at minimum an error bar per condition, is needed before the claim that the method is 'better than all' competitors can be accepted.
[Section 3, 'The experiment'] The random-line generation is underspecified. The text states that lines are 'randomly generated anywhere in the 2D space' but does not give the distribution, the random seed, or whether endpoints are independent and uniform over the 1920x1440 area. If endpoints are uniform, the great majority of segments will miss the 200x150 central window and be rejected in Step 1, so the measured time would mostly reflect trivial-rejection overhead rather than general clipping cost. The authors should specify the generation procedure, report the proportion of lines that actually intersect the window, and add a benchmark in which most lines cross the window.
[Abstract and Section 3] The abstract claims a comparison 'with respect to the number of operations performed', but no operation-count table, formula, or per-case count is provided anywhere in Section 3. The only quantitative evidence is wall-clock time, which conflates clipping cost with drawing cost. Without an explicit count of comparisons, divisions, and assignments for typical cases, the abstract's operational claim and the conclusion that the method uses the minimum number of variables are unsupported.
[Section 3, benchmark reproducibility] The implementations of the six competing algorithms are not made available, and the paper does not describe how the OpenGL drawing call is timed or whether the reported times include the drawing itself. This makes the comparison impossible to reproduce and complicates interpretation, since drawing overhead can mask differences in clipping cost. Providing source code and a precise timing protocol is necessary for the empirical comparison to be verifiable.

minor comments (3)

[Section 2.2, bullets after Eq. (3)] In the bullets for 'If yi < ymin' and 'If yi > ymax', the terms '(ymin−x1)' and '(ymax−x1)' should read '(ymin−y1)' and '(ymax−y1)'; the pseudocode in Section 2.3 is correct.
[Section 2.3] The algorithm does not explicitly state its treatment of zero-length or degenerate segments. For ordinary horizontal or vertical segments that cross the window, the divisions by (x2−x1) and (y2−y1) are not reached, so the division-by-zero concern largely does not land for such inputs; an explicit sentence about the intended domain of the algorithm would nevertheless prevent confusion.
[General] The spelling of the Kodituwakku-Wijeweera-Chamikara algorithm is inconsistent (e.g., 'Wijeweere' in the text versus 'Wijeweera' in reference [13]); please unify the spelling, and also unify the journal volume numbering on the first and subsequent pages.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the speed claim rests on independent benchmark measurements, not on a derivation from the paper's own fitted inputs.

full rationale

The proposed algorithm is derived directly from the slope form of the line equation, Eq. (2) and Eq. (3), which are algebraic restatements of y = mx + b rather than assumptions containing the clipping result. Step 1 uses only boundary inequalities, and Step 2 substitutes window boundaries into the line equation; no parameter is fitted to the timing data and no output quantity is fed back as an input. The Section 3 and Section 4 performance claim is an empirical comparison against six external algorithms, with percentages computed directly from the measured averages in Tables 1 and 2, so there is no 'predicted' quantity that was used to generate the same benchmark. The only self-citation, ref. [17], appears in the introduction as 'see also [17]' and is not load-bearing for the algorithm's correctness or for the speed comparison. Potential concerns about division by zero for axis-aligned lines, the unspecified random-line distribution, or the absence of confidence intervals are correctness and empirical-support issues, not circularity under the stated criteria. The derivation chain is therefore self-contained, and no Eq. X = Eq. Y by construction or fitted parameter renamed as prediction is present.

Assumptions & free parameters 0 free parameters · 1 assumptions · 0 invented entities

The central claim (speed) is empirical; the algorithm itself uses only the standard two-point line equation. The only substantive untested assumption is that the input lines are not axis-aligned, because the formulas divide by coordinate differences. No free parameters or invented entities are introduced.

assumptions (1)

domain assumption The line is not vertical or horizontal (x1 != x2 and y1 != y2).
Step 2 formulas and the pseudocode in Section 2.3 divide by (x2-x1) and (y2-y1); the paper does not state this restriction and explicitly removes the parallel-axis checks present in KWC.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Another Simple but Faster Method for 2D Line Clipping." pith.science (2026). https://pith.science/paper/FBVTGSD2

@misc{pith2026190801350,
  author       = {Pith},
  title        = {Pith review of: Another Simple but Faster Method for 2D Line Clipping},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FBVTGSD2}},
  note         = {Machine review of arXiv:1908.01350}
}

read the original abstract

The majority of methods for line clipping make a rather large number of comparisons and involve a lot of calculations compared to modern ones. Most of the times, they are not so efficient as well as not so simple and applicable to the majority of cases. Besides the most popular ones, namely, Cohen-Sutherland, Liang-Barsky, Cyrus-Beck and Nicholl-Lee-Nicholl, other line-clipping methods have been presented over the years, each one having its own advantages and disadvantages. In this paper a new computation method for 2D line clipping against a rectangular window is introduced. The proposed method has been compared with the afore-mentioned ones as well as with two others; namely, Skala and Kodituwakku-Wijeweera-Chamikara, with respect to the number of operations performed and the computation time. The performance of the proposed method has been found to be better than all of the above-mentioned methods and it is found to be very fast, simple and can be implemented easily in any programming language or integrated development environment.

Figures

Figures reproduced from arXiv: 1908.01350 by the authors.

**Figure 1.** Region before (left) and after (right) 2D line clipping. line, b is the y-intercept of the line and x is the independent variable of the function y = f(x) or just the vector equation. The most common application of clipping is in the viewing pipeline, where clipping is applied to extract a designated portion of a scene (either two-dimensional or three-dimensional) for display on an output device. Clipping methods ar… view at source ↗

**Figure 2.** The nine regions of the Cohen-Sutherland algorithm in the 2D space. The method of Mike Cyrus and Jay Beck is a general line-clipping algorithm, but it introduces extra floating point operations for determining the value of a parameter corresponding to the intersection of the line to be clipped with each window edge [11]. It is of O(N) complexity, where N is a number of facets, and is primarily intended for clipping … view at source ↗

**Figure 3.** Defining the line for clipping with the Liang-Barsky algorithm. the Cohen-Sutherland algorithm. The clipping window is divided into a number of different areas, depending on the position of the initial point of the line to be clipped. The algorithm of Skala [27] is based on homogeneous coordinates and duality. It can be used for line or line-segment clipping against a rectangular window as well as against a convex p… view at source ↗

Figures from the paper (6 more)

**Figure 4.** Figure 4: Line-clipping region. Solving for y y − y1 = m(x − x1) ⇔ y = y1 + m(x − x1). By replacing m in this equation with Eq. (1) y = y1 + y2 − y1 x2 − x1 (x − x1). (2) Solving for x, the equation becomes x = x1 + x2 − x1 y2 − y1 (y − y1). (3) Equations (2) and (3) are two mat…

**Figure 5.** Figure 5: Lines A, B, C, D are rejected according to the first step of the algorithm. Step 2 In the second step, the algorithm compares the coordinates of the two points along with the boundaries of the clipping window. It compares each of the x1 and x2 coordinates with the xmin…

**Figure 6.** Figure 6: Selecting the points of the line that are inside the clipping area. – If xi > xmax, then xi = xmax yi = y1 + y2 − y1 x2 − x1 (xmax − x1) – If yi < ymin, then yi = ymin xi = x1 + x2 − x1 y2 − y1 (ymin − x1) – If yi > ymax, then yi = ymax xi = x1 + x2 − x1 y2 − y1 (ymax …

**Figure 7.** Figure 7: Defining the 2D space for creating random line as well as definition of the line-clipping window. Hardware and software specifications For realistic results, an average computer system was used for the experiment. The hardware as well as the software specifications we…

**Figure 8.** Figure 8: Graph with the average time of each algorithm for 1,000,000 in C++ with OpenGL (from lower to higher value). The Liang-Barsky algorithm performs very well and is almost as fast as the Kodituwakku-Wijeweere-Chamikara algorithm which was the faster algorithm after the p…

**Figure 9.** Figure 9: Graph with the average time of each algorithm for 10,000,000 in C++ with OpenGL (from lower to higher value). is very easy to implement in any programming language or integrated development environment. Both the Cohen-Sutherland and Liang-Barsky algorithms can be exte…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

30 extracted references · 30 canonical work pages

[1]

Andreev and Elena Soﬁanska

R. Andreev and Elena Soﬁanska. New algorithm for two-dimensional line clipping. Comput. Graph., 15(4):519–526, 1991

work page 1991
[2]

Cyrus and J

M. Cyrus and J. Beck. Generalized two- and three-dimensional clipping. Comput. Graph., 3:23–28, 1978

work page 1978
[3]

J. D. Day. An algorithm for clipping lines in object and image space. Comput. Graph. , 16(4):421–426, 1992

work page 1992
[4]

S. C. Dimri. A simple and eﬃcient algorithm for line and polygon clipping in 2-D computer graphics. International Journal of Computer Applications , 127(3):31–34, 2015

work page 2015
[5]

M. D¨ orr. A new approach to parametric line clipping. Comput. Graph. , 14(3/4):449–464, 1990

work page 1990
[6]

J. D. Foley, A. van Dam, S. K. Feiner, and J. F. Hughes. Computer Graphics Principles and Practice. Addison-Wesley, Reading, MA, 2nd edition, 1990

work page 1990
[7]

A. P. Godse and Deepali A. Godse. Computer Graphics. Technical Publications, 2008

work page 2008
[8]

Hearn and M

D. Hearn and M. P. Baker. Computer Graphics C Version . Prentice Hall, 2nd edition, 1997

work page 1997

Show all 30 references

[9]

Hearn, M

D. Hearn, M. Pauline Baker, and W. R. Carithers. Computer Graphics with Open GL. Pearson Education Limited, Edinburgh Gate, Harlow, Essex CM20 2JE, 4th edition, 2014

2014
[10]

M. S. Iraji, A. Mazandarami, and H. Motameni. An eﬃcient line clipping algorithm based on Cohen-Sutherland line clipping algorithm. American Journal of Scientiﬁc Research, 14:65–71, 2011

2011
[11]

Kaijian, J

S. Kaijian, J. A. Edwards, and D. C. Cooper. An eﬃcient line clipping algorithm. Comput. Graph., 14(2):297–301, 1990. 13 International Journal of Computer Graphics & Animation (IJCGA) Vol.9, No.4, July 2019

1990
[12]

S. R. Kodituwakku, K. R. Wijeweera, and M. A. P. Chamikara. An eﬃcient line clipping algorithm for 3D space. International Journal of Advanced Research in Computer Science and Software Engineering, 2(5):96–101, 2012

2012
[13]

S. R. Kodituwakku, K. R. Wijeweera, and M. A. P. Chamikara. An eﬃcient algorithm for line clipping in computer graphics programming. Ceylon Journal of Science (Physical Sciences) , 1(17):1–7, 2013

2013
[14]

An eﬃcient line clipping algorithm for circular windows using vector calculus and parallelization.International Journal of Computer Graphics & Animation (IJCGA) , 8(1/2):1–8, 2018

Prastut Kumar, Fenil Patel, and Rajesh Kanna. An eﬃcient line clipping algorithm for circular windows using vector calculus and parallelization.International Journal of Computer Graphics & Animation (IJCGA) , 8(1/2):1–8, 2018

2018
[15]

Liang and B

Y-D. Liang and B. A. Barsky. A new concept and method for line clipping. tog, 3(1):1–22, 1984

1984
[16]

G. Lu, X. Wu, and Q. Peng. An eﬃcient line clipping algorithm based on adaptive line rejection. Computers and Graphics , 26:409–415, 2002

2002
[17]

Matthes and V

D. Matthes and V. Drakopoulos. A simple and fast line-clipping method as a scratch extension for computer graphics education. Computer Science and Information Technology , 7(2):40–47, 2019

2019
[18]

Nicholl, D.T

Tina M. Nicholl, D.T. Lee, and Robin A. Nicholl. An eﬀective new algorithm for 2-D line clipping: Its development and analysis. Comput. Graph., 21(4):253–262, 1987

1987
[19]

Comparison of various line clipping algorithms: Review

Nisha. Comparison of various line clipping algorithms: Review. International Journal of Advanced Research in Computer Science and Software Engineering , 7(1):68–71, 2017

2017
[20]

A review: Comparison of line clipping algorithms in 3D space

Nisha. A review: Comparison of line clipping algorithms in 3D space. International Journal of Advanced Research, 5(1):2377–2379, 2017

2017
[21]

Pandey and S

A. Pandey and S. Jain. Comparison of various line clipping algorithms for improvement. International Journal of Modern Engineering Research , 3(1):69–74, 2013

2013
[22]

B. K. Ray. An alternative algorithm for line clipping. Journal of Graphic Tools, 16(1):12–24, 2012

2012
[23]

B. K. Ray. A line segment clipping algorithm in 2D. International Journal of Computer Graphics, 3(2):51–76, 2012

2012
[24]

N. C. Sharma and S. Manohar. Line clipping revisited: Two eﬃcient algorithms based on simple geometric observations. Comput. Graph., 16(1):51–54, 1992

1992
[25]

V. Skala. An eﬃcient algorithm for line clipping by convex polygon. Comput. Graph. , 17(4):417–421, 1993

1993
[26]

V. Skala. O(lg N) line clipping algorithm in E2. Comput. Graph., 18(4):517–524, 1994

1994
[27]

V. Skala. A new approach to line and line segment clipping in homogeneous coordinates. Visual Comput., 21:905–914, 2005

2005
[28]

Mel Slater and Brian A. Barsky. 2d line and polygon clipping based on space subdivision. Visual Comput., 10:407–422, 1994

1994
[29]

Information Technology with Management

M. S. Sobkow, P. Pospisil, and Y. Yang. A fast two-dimensional line clipping algorithm via line encoding. Comput. Graph., 11(4):459–467, 1987. Authors Vasileios Drakopoulos received a B.S. degree in Mathematics, an M.S. degree in Informatics & Operations Research and a doctora...

1987
[2005]

He has also worked as a part time teacher in several universities and institutes

From 2005 onwards he works as a teacher of Informatics in secondary educa- tion. He has also worked as a part time teacher in several universities and institutes. Currently, he is pursuing his Ph.D. degree in Computer Science and Biomedical In- formatics from the University of...

2005

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.

[1] [1]

Andreev and Elena Soﬁanska

R. Andreev and Elena Soﬁanska. New algorithm for two-dimensional line clipping. Comput. Graph., 15(4):519–526, 1991

work page 1991

[2] [2]

Cyrus and J

M. Cyrus and J. Beck. Generalized two- and three-dimensional clipping. Comput. Graph., 3:23–28, 1978

work page 1978

[3] [3]

J. D. Day. An algorithm for clipping lines in object and image space. Comput. Graph. , 16(4):421–426, 1992

work page 1992

[4] [4]

S. C. Dimri. A simple and eﬃcient algorithm for line and polygon clipping in 2-D computer graphics. International Journal of Computer Applications , 127(3):31–34, 2015

work page 2015

[5] [5]

M. D¨ orr. A new approach to parametric line clipping. Comput. Graph. , 14(3/4):449–464, 1990

work page 1990

[6] [6]

J. D. Foley, A. van Dam, S. K. Feiner, and J. F. Hughes. Computer Graphics Principles and Practice. Addison-Wesley, Reading, MA, 2nd edition, 1990

work page 1990

[7] [7]

A. P. Godse and Deepali A. Godse. Computer Graphics. Technical Publications, 2008

work page 2008

[8] [8]

Hearn and M

D. Hearn and M. P. Baker. Computer Graphics C Version . Prentice Hall, 2nd edition, 1997

work page 1997