lập trình đồ họa trên nền tảng ngôn ngữ lâp trình Java

Lập trình đồ họa trên Java 2D và 3D
Phần 1..................................................................................................................................8
Lập trình đồ họa với Java 2D..............................................................................................8
Chương 1.........................................................................................................................9
Tổng quan về Java 2D API.............................................................................................9
1.1 Enhanced Graphics, Text, and imaging................................................................9
1.2 Rendering Model................................................................................................10
1.2.1 Coordinate Systems.....................................................................................10
1.2.1.1 User Space...........................................................................................10
1.2.1.2 Device Space.......................................................................................10
1.2.2 Transforms...................................................................................................11
1.2.3 Fonts.............................................................................................................11
1.2.4 Images..........................................................................................................12
1.2.5 Fills and Strokes..........................................................................................13
1.2.6 Composites..................................................................................................13
Backward Compatibility and Platform independence..............................................14
1.3.1 Backward Compatibility..............................................................................14
1.3.2 Platform independence................................................................................15
1.4 The Java 2D™ API Packages.............................................................................15
Chương 2:......................................................................................................................18
Rendering with Graphics2D.........................................................................................18
2.1 Các lớp và giao diện...........................................................................................18
2.2 Rendering Concepts............................................................................................19
2.2.1 Rendering Process.......................................................................................19
2.2.2 Controlling Rendering Quality....................................................................20
2.2.3 Stroke Attributes..........................................................................................21
2.2.4 Fill Attributes...............................................................................................22
Quá trình xử lý theo phiên................................................................................22
2.2.5 Clipping Paths..............................................................................................23
2.2.6 Transformations...........................................................................................23
2.2.6.1 Constructing an AffineTransform.......................................................24

2.2.7 Composite Attributes...................................................................................25
2.2.7.1 Managing Transparency......................................................................25
2.2.7.2 Transparency and images....................................................................26
2.3 Thiết lập Graphics2Context................................................................................26
2.3.1 Setting Rendering Hints..............................................................................26
2.3.2 Specifying Stroke Attributes.......................................................................26
2.3.2.1 Setting the Stroke Width.....................................................................27
2.3.2.2 Specifying Join and Endcap Styles.....................................................27
2.3.2.3 Setting the Dashing Pattern.................................................................27
2.3.3 Specifying Fill Attributes............................................................................28
2.3.3.1 Filling a Shape with a Gradient...........................................................28
2.3.3.2 Filling a Shape with a Texture............................................................28
2.3.4 Setting the Clipping Path.............................................................................29
2.3.5 Setting the Graphics2D Transform.............................................................30
2.3.6 Specifying a Composition Style..................................................................31
2.3.6.1 Using the Source Over Compositing Rule..........................................31
2.3.6.2 Increasing the Transparency of Composited Objects.........................31
2.4 Rendering Graphics Primitives...........................................................................32
2.4.1 Drawing a Shape..........................................................................................32
2.4.2 Filling a Shape.............................................................................................33
1
Lập trình đồ họa trên Java 2D và 3D
2.4.3 Rendering Text............................................................................................34
2.4.4 Rendering images........................................................................................34
2.5 Defining Custom Composition Rules.................................................................34
2.6 Rendering in a Multi-Screen Environment........................................................34
Chương 3.......................................................................................................................42
Các đối tượng hình họa.................................................................................................42
3.1 Giao diện và lớp..................................................................................................42
3.2 Các khái niệm hình học:.....................................................................................44

3.2.1 Constructive Area Geometry.......................................................................44
3.2.2 Bounds and Hit Testing...............................................................................44
3.3 Combining Areas to Create New Shapes...........................................................48
Chương 4:......................................................................................................................51
Hiển thị Font và văn bản...............................................................................................51
4.1.Giao diện và lớp..................................................................................................51
4.2.Các khái niệm về Font........................................................................................52
4.3 Các khái niệm về Text Layout...........................................................................53
4.3.1 Vẽ chữ..........................................................................................................53
4.3.2 Ordering Text...............................................................................................55
4.3.3 Đo và định vị văn bản.................................................................................56
4.3.4 Hỗ trợ thao tác với văn bản.........................................................................56
4.3.4.1 Hiển thị dấu nhắc..................................................................................56
4.3.4.2 Di chuyển dấu nhắc.............................................................................57
4.3.4.3 Hit Testing...........................................................................................58
4.3.4.4 Đánh dấu vùng lựa chọn.....................................................................59
4.3.5 Thực thi việc hiển thị văn bản trong ứng dụng Java™ .............................59
Quản lý việc hiển thị văn bản...................................................................................60
4.4.1 Trình bày văn bản........................................................................................61
Hiển thị dấu nhắc kép...........................................................................................61
4.4.3 Di chuyển dấu nhắc.....................................................................................62
4.4.4 Hit Testing...................................................................................................62
4.4.5 Đánh dấu vùng lựa chọn..............................................................................62
4.4.6 Querying Layout Metrics............................................................................62
4.4.7 Vẽ văn bản trên nhiều dòng.........................................................................63
Chương 5.......................................................................................................................67
Tạo ảnh..............................................................................................................................67
5.1 Các giao diện và các lớp................................................................................67
5.1.1 Các giao diện imaging (imaging interfaces)..............................................67
5.1.2 Các lớp dữ liệu ảnh(image Data Classes)...................................................68

5.1.3 image Operation Classes.............................................................................68
5.1.4 Sample Model Classes.................................................................................69
Color Model Classes.............................................................................................70
5.1.6 Exception Classes........................................................................................70
5.2 Immediate Mode imaging Concepts...................................................................71
5.2.1 Terminology................................................................................................72
5.3 Using Bufferedimages........................................................................................73
5.3.1 Creating a Bufferedimage............................................................................73
5.3.2 Drawing in an Offscreen Buffer..................................................................73
5.3.2.1 Creating an Offscreen Buffer..............................................................74
5.3.2.2 Drawing in an Offscreen Buffer..........................................................75
5.3.3 Manipulating Bufferedimage Data Directly...............................................75
2
Lập trình đồ họa trên Java 2D và 3D
5.3.4 Filtering a Bufferedimage...........................................................................76
5.3.5 Rendering a Bufferedimage ........................................................................76
5.4 Managing and Manipulating Rasters..................................................................79
5.4.1 Creating a Raster.........................................................................................79
5.4.2 Parent and Child Rasters.............................................................................79
5.4.4 The WritableRaster Subclass.......................................................................80
5.5 Image Data and DataBuffers..............................................................................80
5.6 Extracting Pixel Data from a SampleModel......................................................80
5.7 ColorModels and Color Data..............................................................................81
5.7.1 Lookup Table...............................................................................................81
5.8 image Processing and Enhancement..................................................................82
5.8.1 Using an image Processing Operation........................................................83
Chương 6.......................................................................................................................86
Mầu sắc.........................................................................................................................86
6.1 Các lớp ...............................................................................................................86
6.2 Những định nghĩa về mầu sắc............................................................................86

6.2.1 Không gian mầu..........................................................................................87
6.2.1 Biểu diễn màu.............................................................................................89
Chương 7 ......................................................................................................................91
In ấn...............................................................................................................................91
7.1 Các giao diện và các lớp.....................................................................................91
7.2.1 Supporting Printing......................................................................................92
7.2.1.1 Điều khiển in (Job Control)................................................................92
7.2.2 Page Painters................................................................................................93
7.2.3 Printable Jobs and Pageable Jobs................................................................94
7.2.4 Typical Life-Cycle of a PrinterJob......................................................................94
7.3 Printing with Printables......................................................................................96
7.3.2 Printing a File..............................................................................................97
7.4.1 Using a Pageable Job.................................................................................100
7.4.2 Using Multiple Page Painters....................................................................101
Phần 2..............................................................................................................................107
Lập trình đồ họa với Java 3D.........................................................................................107
CHƯƠNG 1................................................................................................................108
NHẬP MÔN LẬP TRÌNH TRÊN JAVA 3D............................................................108
1.1 Tổng quan về Java 3D API ™..........................................................................108
1.2 Các vấn đề cơ bản về Java 3D API™ .............................................................108
1.3 Xây dựng đồ thị khung cảnh............................................................................109
1.3.1 Thừa kế cấp cao từ Java 3D API ..............................................................112
1.4 Cách thức để viết một chương trình Java 3D.......................................................113
1.4.1 Công thức đơn giản để viết một chương trình Java 3D ...........................113
1.5 Một vài thuật ngữ trong Java 3D .....................................................................116
1.6 Ví dụ đơn giản: HelloJava3Da ........................................................................117
1.6.1 Các lớp của Java 3D Classes được sử dụng trong HelloJava3Da................120
Tạo nên hình lập phương có kích thước được định ra bởi các giá trị cho trước.......123
1.7 Quay hình lập phương.....................................................................................123
1.7.1 Sự kết hợp của các phép biến hình: HelloJava3Db..................................124

1.8 Khả năng và hoạt động.....................................................................................124
1.8.1 Dịch các nội dung......................................................................................125
1.8.2 Khả năng ...................................................................................................125
1.9 Thêm vào các hành vi animation......................................................................126
3
Lập trình đồ họa trên Java 2D và 3D
1.9.1 Định nghĩa các hành vi animation.............................................................127
1.9.2 Các hàm biến đổi về thời gian: Ánh xạ một hành vi với thời gian..........127
1.9.3 Lập danh mục các vùng.............................................................................128
1.9.4 Ví dụ về hành vi: HelloJava3Dc ..............................................................129
1.9.5 Phép biến hình và kết hợp các hành vi .Ví dụ: HelloJava3Dd ................130
CHƯƠNG 2................................................................................................................133
Tạo các hình................................................................................................................133
2.1 Hệ tọa độ thế giới ảo........................................................................................133
2.2 Visual Object Definition Basics.......................................................................133
2.2.1 An Instance of Shape3D Defines a Visual Object...................................134
2.2.2 Node Components.....................................................................................135
2.2.3 Defining Visual Object Classes.................................................................135
2.3 Các lớp tiện ích hình học .................................................................................136
2.3.1 Box.............................................................................................................137
2.3.2 Cone ..........................................................................................................137
2.3.3 Cylinder.....................................................................................................138
2.3.4 Sphere........................................................................................................138
2.3.5 More About Geometric Primitives............................................................139
2.3.6 ColorCube .................................................................................................139
2.3.7 Example: Creating a Simple Yo-Yo From Two Cones ...........................139
2.4 Các lớp toán học...............................................................................................143
2.4.1 Point Classes .................................................................................................145
2.4.2 Color Classes.............................................................................................145
2.4.3 Vector Classes...........................................................................................146

2.4.4 TexCoord Classes......................................................................................147
2.5 Các lớp hình học...............................................................................................147
2.5.1 GeometryArray Class ...............................................................................148
2.5.2 Subclasses of GeometryArray ..................................................................152
2.5.3 Subclasses of GeometryStripArray...........................................................153
2.5.4 Subclasses of IndexedGeometryArray......................................................157
2.5.5 Axis.java is an Example of IndexedGeometryArray ...............................159
2.6 Appearance and Attributes...............................................................................159
2.6.1 Appearance NodeComponent...................................................................160
2.6.2 Sharing NodeComponent Objects ............................................................160
2.6.3 Attribute Classes .......................................................................................161
2.6.4 Example: Back Face Culling ....................................................................166
2.7 Bounds and Scope ............................................................................................171
2.7.1 Bounds Node Components .......................................................................171
2.7.2 BoundingLeafa Node ................................................................................174
2.7.3 Scope..........................................................................................................175
2.8 Hình học nâng cao............................................................................................176
2.8.1 Multiple Geometries in a Single Shape3D ...............................................176
2.8.2 GeometryArray .........................................................................................178
2.8.4 AlternateAppearance <new in 1.2> ..........................................................181
2.9 Clipping – Cắt xén............................................................................................183
2.9.1 View Defines a Frustum............................................................................183
2.9.2 Clip Node ..................................................................................................185
2.9.4 ModelClip Example ..................................................................................185
CHƯƠNG 3................................................................................................................188
TẠO NỘI DUNG........................................................................................................188
4
Lập trình đồ họa trên Java 2D và 3D
3.1 Nội dung chính.................................................................................................188
3.1.1 GeometryInfo.............................................................................................188

3.2.1 Một ví dụ đơn giản về GeometryInfo...........................................................189
3.2.2 Sử dụng GeometryInfo..............................................................................189
3.2.3 Một số lớp thông dụng có liên quan đến GeometryInfo...........................190
Loaders....................................................................................................................193
Một ví dụ đơn giản sử dụng leader....................................................................193
Các loader phổ biến...............................................................................................193
3.3.3 Giao diện của gói Loader và lớp cơ sở..................................................194
Viết một loader.......................................................................................................196
Công việc của một loader...................................................................................196
Hàm tạo lớp Loader............................................................................................197
Viết một File Loader đơn giản...........................................................................198
Text2D....................................................................................................................203
3.5.1 Ví dụ Text2D đơn giản..............................................................................204
3.5.2 Lớp Text2D...............................................................................................204
Text3D....................................................................................................................205
Một ví dụ Text3D...............................................................................................206
Những lớp liên quan để tạo ra đối tượng Text3D..............................................207
Nền không gian đồ họa ..........................................................................................211
Một ví dụ background........................................................................................211
Lớp Background.................................................................................................212
CHƯƠNG 4................................................................................................................214
TƯƠNG TÁC.............................................................................................................214
4.1 Hành vi: Cơ sở của tương tác và hoạt hình......................................................214
4.1.1 Ứng dụng của hành vi...............................................................................214
4.1.2 Tổng quan lớp Behaviour..........................................................................215
4.2 Cơ bản về hành vi.............................................................................................215
4.2.1 Viết một lớp Behaviour.............................................................................216
4.2.2 Sử dụng một lớp Behaviour......................................................................218
4.2.3 Các hàm API trong lớp Behaviour............................................................221
4.3 Điều kiện kích hoạt: Cách kích hoạt các hành vi.............................................222

4.3.1 Điều kiện kích hoạt....................................................................................223
4.3.2 WakeupCriterion.......................................................................................223
4.3.3 Quy định lớp WakeupCriterion.................................................................224
4.3.4 Thành phần của WakeupCondition ..........................................................232
4.4 Lớp Behaviour tiện ích xử lý bàn phím...........................................................233
4.4.1 Một ví dụ đơn giản....................................................................................233
4.4.2 Lớp KeyNavigatorBehaviour và KeyNavigator.....................................234
4.5 Lớp tiện ích tương tác với chuột......................................................................235
4.5.1 Sử dụng lớp MouseBehaviour ..................................................................235
4.5.2 Mouse Behaviour Foundation...................................................................238
4.5.3 Các lớp MouseBehaviour .........................................................................238
4.5.4 Mouse Navigation.....................................................................................240
4.6 Picking Object...................................................................................................241
4.6.1 Using Picking Utility Classes....................................................................244
4.6.2 Các hàm API cơ bản trong các lớp Picking .............................................246
4.6.3 Các lớp picking..........................................................................................251
4.6.4 Các lớp Picking Behavior .........................................................................253
CHƯƠNG 5................................................................................................................254
5
Lập trình đồ họa trên Java 2D và 3D
Hoạt Hình....................................................................................................................254
Animation - Hoạt hình:...........................................................................................255
Đối tượng Interpolator và Alpha với hoạt ảnh dựa thời gian...............................256
Alpha.......................................................................................................................256
Sử dụng các đối tượng Interpolator và Alpha:......................................................258
Ví dụ sử dụng lớp Alpha và RotationInterpolator:................................................258
Alpha API:..............................................................................................................261
Các lớp hành vi Interpolator :.................................................................................263
Core Interpolator API:...........................................................................................270
Các lớp đối tượng nội suy đường:..........................................................................274

Lớp Billboard :............................................................................................................279
Sử dụng đối tượng Billboard .................................................................................279
Chương trình ví dụ sử dụng Billboard ..................................................................281
Giao diện lập trình ứng dụng của Billboard (Billboard API)..............................283
OrientedShape3D....................................................................................................284
Giao diện lập trình ứng dụng của OrientedShape3D.............................................284
Ví dụ sử dụng OrientedShape3D............................................................................285
Hoạt ảnh mức chi tiết (Level Of Detail Animations).............................................286
Sử dụng đối tượng DistanceLOD...........................................................................287
Các lỗi thường gặp khi sử dụng LOD ...............................................................287
Ví dụ sử dụng DistanceLOD..................................................................................287
Giao diện lập trình ứng dụng DistanceLOD API...................................................290
Morph .....................................................................................................................291
Sử dụng đối tượng Morph .....................................................................................291
Ví dụ sử dụng Morph .............................................................................................292
Giao diện lập trình ứng dụng Morph API.............................................................295
Giao diện GeometryUpdater.......................................................................................296
Sử dụng GeometryUpdater.....................................................................................296
Chương trình ví dụ hệ thống phân tử đài phun nước sử dụng GeometryUpdater.296
Lời nói đầu
Sự phát triển của khoa học, kĩ thuật, nghệ thuật, kinh doanh, và công nghệ
luôn luôn phụ thuộc vào khả năng truyền đạt thông tin của chúng ta, hoặc thông
qua các bit dữ liệu lưu trữ trong microchip hoặc thông qua giao tiếp bằng tiếng
nói. Câu châm ngôn từ xa xưa “một hình ảnh có giá trị hơn cả vạn lời" hay "trăm
nghe không bằng một thấy" cho thấy ý nghĩa rất lớn của hình ảnh trong việc
chuyển tải thông tin. Hình ảnh bao giờ cũng được cảm nhận nhanh và dễ dàng
hơn, đặc biệt là trong trường hợp bất đồng về ngôn ngữ. Do đó không có gì ngạc
nhiên khi mà ngay từ khi xuất hiện máy tính, các nhà nghiên cứu đã cố gắng sử
dụng nó để phát sinh các ảnh trên màn hình. Trong suốt gần 50 năm phát triển
của máy tính, khả năng phát sinh hình ảnh bằng máy tính của chúng ta đã đạt tới

mức mà bây giờ hầu như tất cả các máy tính đều có khả năng đồ họa.Đồ họa
máy tính là một trong những lĩnh vực lí thú nhất và phát triển nhanh nhất của tin
học. Ngay từ khi xuất hiện, đồ họa máy tính đã có sức lôi cuốn mãnh liệt, cuốn
hút rất nhiều người ở nhiều lĩnh vực khác nhau như khoa học, nghệ thuật, kinh
doanh, quản lí, ... Tính hấp dẫn và đa dạng của đồ họa máy tính có thể được
minh họa rất trực quan thông qua việc khảo sát các ứng dụng của nó.
6
Lập trình đồ họa trên Java 2D và 3D
Ngày nay, đồ họa máy tính được sử dụng trong rất nhiều lĩnh vực khác
nhau như công nghiệp, thương mại, quản lí, giáo dục, giải trí, … Số lượng các
chương trình đồ họa ứng dụng thật khổng lồ và phát triển liên tục.Trong lĩnh vực
công nghiệp,CAD(computer-aided design) đã được sử dụng hầu hết trong việc
thiết kế các cao ốc, ô tô, máy bay, tàu thủy, tàu vũ trụ, máy tính,…Trong lĩnh
vực giải trí,nghệ thuật, đồ họa máy tính giúp ta tạo ra các chương trình trò
chơi,các kĩ xảo điện ảnh cho các nhà làm phim,hay ngay chính giao diện đồ họa
đã làm nâng cao khả năng giao tiếp giữa người và máy tính.
Để có thể làm được những ứng dụng đồ họa hữu ích cho cuộc sống,trước
hết chúng ta cần phải có một nền tảng vững chắc về lập trình đồ họa.Có rất nhiều
ngôn ngữ hỗ trợ lập trình đồ họa máy tính,mỗi ngôn ngữ được xây dưng trên
những thư viện đồ họa riêng,có những thế mạnh riêng.Và khi nói về lập trình đồ
họa,chúng ta không thể không nói đến ngôn ngữ Java,một ngôn ngữ rất mạnh
trong lĩnh vực này.Với mục đích nghiên cứu,tìm hiểu và mang đến cho những ai
muốn tìm hiều về lập trình đồ họa một tài liệu thiết thực,nhóm chúng em đã chọn
đề tài làm tutorial về lập trình đồ họa trên nền tảng ngôn ngữ lâp trình Java,dựa
trên các tài liệu training trên mạng của hãng Sun.Vì là lần đầu làm tài liệu tham
khảo nên chúng em không tránh khỏi sai sót.Chúng em mong thầy xem xét và
góp ý cho tài liệu này.Chúng em chân thành cảm ơn.
7
Lập trình đồ họa trên Java 2D và 3D
Phần 1

Lập trình đồ họa với Java 2D
8
Lập trình đồ họa trên Java 2D và 3D
Chương 1
Tổng quan về Java 2D API
Java 2D™ API tăng cường về khả năng đồ hoạ, văn bản và ảnh của Abstract
Windowing Toolkit (AWT), giúp phát triển về giao diện người sủ dụng và ứng dụng về
JAVA trong một số lĩnh vực mới.Cùng với khả năng mạnh về đồ hoạ ,phông chữ và
ảnh trong các API, thì Java 2D API còn hỗ trợ những thuộc tính và thành phần màu sắc
đã được nâng cao, và thành công trong việc biểu diễn các bề mặt hình học tuỳ ý và một
kiểu tô trát chuẩn cho máy in và thiết bị hiển thị. Java 2D API cũng cho phép tạo ra các
thư viện đồ hoạ mở rộng,như các thư viện của CAD-CAM và các thư viện tạo hiệu ứng
đặc biệt cho ảnh và đồ hoạ, cũng như việc tạo ra các bộ lọc đọc/viết file ảnh và đồ
hoạ.Khi được sử dụng kết hợp với Java Media Framework Java Media APIs khác ,thì
Java 2D APIs có thể được sử dụng để tạo ra và hiển thị hiện thực ảo và các dạng đa
phương tiện khác. Java Animation và Java Media Framework APIs dưa trên Java 2D
API để hỗ trợ việc tô trát(rendering).
1.1 Enhanced Graphics, Text, and imaging
Nếu các phiên bản trước của AWT chỉ cung cấp các gói tô trát(rendering) đơn giản
chỉ phù hợp cho việc rendering các trang HTML đơn giản,mà không đáp ứng đủ cho
các dạng đồ hoạ,văn bản và ảnh phức tạp. Thì Java 2D™ API cung cấp gói tô trát đẩy
đủ các tính năng bằng cách mở rộng AWT để hỗ trợ cho đồ hoạ và các thao tác
rendering. Ví dụ như thông qua các lớp đồ hoạ cho phép vẽ hình chữ nhật,hình ôval,và
các đa giác. Đồ hoạ 2D tăng cường về khái niệm của phép tô trát hình học bằng cách
cung cấp một cơ chế cho phép rendering ảo của bất kì bề mặt hình học nào.Tương tư
như vậy với Java 2D API bạn có thể vẽ các dạng đường với bất kì độ rộng và dạng
hình học nào.
Dạng hình học được cung cấp thông qua các phần thực thi implementations của
Shape interface trong Graphic class, như hình chữ nhật 2D và Elip 2D. Các đường
cong và hình cung cũng thuộc phần implementations của Shape. Các kiểu vẽ và tô cũng

được cung cấp thông qua phần thực thi implementations của giao tiếp Paint và Stroke
interfaces, ví dụ BasicStroke, GradientPaint, TexturePaint,và Color.
AffineTransform định nghĩa các phép biến đổi trong toạ độ 2 chiều, gồm có phép
lấy tỉ lệ,phép chuyển đổi toạ độ ,phép quay và phép xén cắt.
Khung nhìn được định nghĩa bởi các phương thức giống nhau của lớp Shape mà
chúng được dùng để định nghĩa các khung nhìn chung,ví dụ như Rectangle2D và
GeneralPath.
Thành phần màu sắc được cung cấp bởi các phương thức của lớp Composite, ví dụ
AlphaComposite.
Một kiểu Font chữ thì được định nghĩa bởi các collection của Glyphs.
9
Lập trình đồ họa trên Java 2D và 3D
1.2 Rendering Model
Kiểu tô trát đồ họa đơn giản không có gì thay đổi khi thêm vào Java 2D™ APIs.
Để tô trát đồ họa thì phải thiết lập các thông số về đồ họa và gọi phương thức của đối
tượng Graphics.
Trong Java 2D API, lớp Graphics2D mở rộng lớp Graphics để hỗ trợ thêm nhiều
thuộc tính đồ họa và cung cấp thêm các phương thức cho quá trình tô trát.
The Java 2D API tự động cân chỉnh những sai khác trong các thiết bị tô trát và cung cấp
một kiểu tô trát thống nhất cho các dạng thiết bị khác nhau. Tại tầng ứng dụng,quá
trình tô trát là giống nhau cho dù thiết bị cuối đó là màn hình hay máy in.
Với Java 2 SDK, version 1.3 , Java 2D API còn hỗ trợp cho các môi trường đa màn
hình (multi-screen environments).
1.2.1 Coordinate Systems
Java 2D API bao hàm hai hệ tọa độ:
1. Không gian người sủ dụng là hệ tọa độ logic và độc lập với thiết bị. Các ứng
dụng thường sủ dụng hệ tọa độ này,tất cả các dạng hình học được tô trát bằng
Java 2D đều được xác định trong hệ tọa độ này.
2. Không gian thiết bị là hệ tọa độ phụ thuộc thiết bị,ứng với từng loại thiết bị cuối
mà có hệ tạo độ khác nhau.

Bằng ứng dụng máy ảo một cửa sổ hiển thị có thể mở rộng thêm nhiều thiết bị hiển
thị vậy lý tạo nên môi trường đa màn hiển thị, hệ tọa độ của thiết bị này được sủ dụng
làm hệ tọa độ của máy ảo sẽ được lấy làm hệ tọa độ cho tất cả các màn hiể thị còn lại.
Hệ thống Java 2D sẽ tự động thực hiện những phép chuyển đổi cần thiết giữa không
gian người sử dụng và không gian thiết bị . Mặc dù hệ tọa độ cho màn hình rất khác đối
với hệ tọa độ cho máy in nhưng sự khác biệt này trong suốt đối với các ứng dụng.
1.2.1.1 User Space
Hệ tọa độ này được chỉ ra trong hình 1-1.
(0,0)
x
y
Figure 1-1 User Space Coordinate System
Không gian người sử dụng biểu diễn một cách trừu tượng đồng nhất cho các hệ tạo
độ của tất cả các thiết bị có liên quan.Còn không gian thiết bị cho một thiết bị cụ thể có
thể có cùng gốc tọa độ và hướng của các trục hoặc là có thể không.Ngoài ra các tọa độ
của không gian người sử dụng có thể chuyển đổi một cách tự động vào không gian thiết
bị phù hợp mỗi khi một đối tượng đồ họa được tô trát,thường thì các chương trình
driver của các thiết bị thực hiện điều này.
1.2.1.2 Device Space
10
Lập trình đồ họa trên Java 2D và 3D
Java 2D API định nghĩa 3 mức thông tin cấu hình để hỗ trợ cho việc chuyển đổi từ
không gian người sử dụng sang không gian thiết bị. Thông tin này được chứa trong 3
lớp :
• GraphicsEnvironment
• GraphicsDevice
• GraphicsConfiguration
Hai trong số chúng sẽ biểu diễn tất cả các thông tin cần thiết cho việc xác định thiết
bi tô trát và cho việc chuyển đổi tọa độ từ không gian người sử dụng sang không gian
thiết bị. Ứng dụng có thể truy cập thông tin này nhưng không nhất thiết phải thực hiện

bất kì phép chuyển đổi nào giũa hai hệ tọa độchuyển .
Lớp GraphicsEnvironment mô tả tập các thiết bị mà đựợc chấp nhận bởi các ứng
dụng Java trong một môi trường cụ thể.Các thiết bị sử dụng cho quá trình tô trát gồm có
màn hình , má in và các bộ đệm ảnh.Lớp GraphicsEnvironment cũng bao gồm tập các
font phù hợp trong môi trường đó.
Lớp GraphicsDevice mô tả thiết bị tô trát như màn hình hoặc máy in.Mỗi cấu hình phù
hợp của thiết bị được biểu diễn bởi lớp GraphicsConfiguration. Ví dụ,một thiết bị
hiển thị SVGA có thể thực hiện trong một số chế độ màu như : 640x480x16 colors,
640x480x256 colors, and 800x600x256 colors.
Màn hình SVGA được biểu diễn bởi một đối tượng GraphicsDevice và ứng với
mỗi chế độ màu của màn hình SVGA sẽ được biểu diễn bởi một đối tượng
GraphicsConfiguration.Một đối tượng kiểu GraphicsEnvironment có thể bao gồm 1
hay nhiều đối tượng GraphicsDevices. Ngược lại ,mỗi đối tượng GraphicsDevice có
thể có 1 hay nhiều đối tượng kiểu GraphicsConfigurations.
1.2.2 Transforms
Java 2D API có một chế độ chuyển tọa độ thống nhất. Tất cả các phép chuyển tọa
độ,bao gồm các phép chuyển từ không gian người sử dụng đến không gian của thiết
bị,đều được biểu diễn bởi đối tượng kiểu AffineTransform .AffineTransform định
nghĩa các luật cho những thao tác trên các hệ tọa độ bằng các ma trận(các phép biến đổi
ảnh bằng các bộ lọc).
Cũng có thể thêm đối tượng AffineTransform cho các dạng đồ họa bằng các phép
xoay ,lấy tỉ lệ ,chuyển đổi hoặc cắt tọa độ cho một mặt hình học ,văn bản hay ảnh khi
chúng được tô trát.Các phép biến đổi được thêm vào này sẽ được ứng dụng cho các đối
tượng đồ họa được tô trát trong trường hợp đó phép bién đổi này được thực hiện khi
chuyển từ tọa độ không gian người sử dụng sang không gian của thiết bị.
1.2.3 Fonts
Một xâu thường được hiểu là tập các kí tự tao thành.Khi một xâu được vẽ, hình
dạng của nó sẽ được xác định bởi font mà chúng ta chọn.Tuy nhiên, hình dạng mà font
sử dụng để hiển thị lên màn hình xâu đó không phải lúc nào cũng giống với hình dáng
của mỗi kí tự riêng biệt. ví dụ sự kết hợp của 2 hay nhiều kí tự thường được thay thế

bởi một hình dạng kí hiêu nào đó được gọi là ligature.
Các hình dạng mà một phông chữ sử dụng để biểu diễn các kí tự trong một xâu được
gọi là glyphs. Một font có thể biểu diễn một kí tự như chữ thường hoặc chữ hoa bằng
cách sử dụng nhiều glyphs, hoặc biểu diễn các liên kết kí tự như fi chỉ biểu diễn bởi 1
glyph. Trong Java 2D API, một glyph chỉ đơn giản là một dạng (Shape) mà có thể
đựoc thao tác và tô trát một cách giống nhau như bất kì với các dạng khác Shape.
Một font có thể được xem như tập các glyph. Một font đơn có thể có rất nhiều kiểu
khác nhau như kểi chữ đậm ,vừa,nghiêng ,gôtích…tất cả các kiểu chữ này trong một
font có cùng thiết kế in và có thể ví như chúng là các thành viên trong cùng một gia
11
Lập trình đồ họa trên Java 2D và 3D
đình. Hay nói cách khác ,một nhóm các glyphs với các kiểu riêng biệt tạo nên một dạng
font,nhóm các dạng font tao nên môt họ font ,họ các font tạo nên một tập font và tập
này có sẵn trong một đối tượng GraphicsEnvironment cụ thể nào đó.
Trong Java 2D API, các font được xác định bởi một tên mà mô tả một dạng font
riêng biệt nào đó,ví dụ Helvetica Bold. Nhưng điều này lại khác với fần mềm JDK
1.1 ,các font được mô tả bằng các tên lôgíc mà ánh xạ trên các dạng font khác nhau fụ
thuộc liệu các dạng font đó có sắn trong môi trường đang xét không.Như để tương thích
cho điều đó ; the Java 2D API hỗ trợ việc xác định các font bằng tên lôgíc cũng như
bằng tên dạng font.
Sử dụng Java 2D API, có thể soạn thảo và tô rát các xâu bao gồm nhiều font thuộc
các họ font,hình dạng,kich thước, và thâm chí cả ngôn ngữ khác nhau. Các dạng của
văn bản được lưu riêng biệt một cách lôgíc với sự sắp xếp các văn bản.Các đối tượng
Font được sử dụng để mô tả các hình dạng hiển thị của font, và thông tin sắp xếp được
lưu trong đối tượng TextLayout và TextAttributeSet . Việc lưu giứ các font và thông
tin sắp xếp riêng biệt nhau làm dễ dàng hơn cho việc sử dụng cùng font chữ nhưng
khác về cấu hình sắp xếp.
1.2.4 Images
Ảnh được tạo nên từ tập các pixel . Một điểm ảnh hay một pixel sẽ định nghĩa thể
hiện của một ảnh tại vùng quan sát của màn hình . Một mảng hai chiều của điểm ảnh

được gọi là một raster.
Thể hiện của một điểm ảnh có thể được định nghĩa một cách trực tiếp hoặc như là
một chỉ số trong bảng màu dành cho ảnh.
Trong ảnh màu đa màu (hơn 256 màu) các điểm ảnh thường trực tiếp biểu diễn
luôn màu sắc và các đặc trưng khác cho mỗi vùng hiển thị của ảnh. Những ảnh như vậy
sẽ có kích thước lớn hơn ảnh màu mà hiển thị bằng chỉ số(indexed-color images),
nhưng chúng nhìn sẽ thật hơn .
Trong ảnh màu hiển thị bằng chỉ số (indexed-color image), những màu sắc của ảnh
sẽ bị giới hạn bởi bảng màu , và thường số lượng màu trong bảng màu sẽ ít hơn sovới
ảnh thật. Tuy nhiên các ảnh khi được lưu như tập các chỉ số màu sẽ làm cho kích thước
ảnh nhỏ đi.Định dạng này thường được dùng cho những ảnh có 256 màu.
Ảnh trong Java 2D API có hai thành phần chính
• Dữ liệu ảnh thô(các điểm ảnh)
• Những thông tin cần thiết cho quá trình chuyển đổi các điểm ảnh
Các luật cho việc chuyển đổi các điểm ảnh được lưu bởi đối tượng ColorModel.
Đối với một điểm ảnh để hiển thị cần phải đi kèm với một kiểu màu sắc.
Một dải màu là một thành phần của không gian màu sắc dành cho ảnh.Ví dụ các
thành phần màu đỏ là các daỉ màu trong ảnh RGB . Một điểm ảnh trong ảnh dùng màu
trực tiếp có thể được hiểu như một tập .
Gói java.awt.image bao gồm một số phương thức ColorModel cho các biểu diễn
thành phần điểm ảnh.
Một đối tượng ColorSpace chứa các luật để sao cho tập các giá trị màu tương ứng
với một màu sắc nhất định .Các phương thức của ColorSpace trong java.awt.color sẽ
biẻu diễn các không gian màu sắc thông dụng, gồm có không gian màu RGB và gray
scale. Lưu ý rằng một không gian màu không phải là một tập các màu sắc mà tập này
định nghĩ các luật để có thể chuyển đổi các giá trị màu thành các màu tương ứng thông
dịch.
12
Lập trình đồ họa trên Java 2D và 3D
Việc chia không gian màu sắc thành các chế độ màu sẽ tạo nên sự linh hoạt hơn

trong việc biểu diễn và chuyển đổi từ phép biểu diễn màu này sang một phếp biểu diẽn
màu khác.
1.2.5 Fills and Strokes
Với Java 2D API, có thể tô các hình băng cách sử dụng các kiểu but khác nhau và
các kiểu tô khác nhau. Vì các chữ xét cho cùng cũng được biểu diễn bằng tập các glyph,
nên các xâu kí tự cũng có thể được vẽ và tô.
Các kiểu bút được định nghĩa băng các đối tượng kiểu Stroke.Có thể xác định độ
rộng cũng như các nét cho các đường thẳng và đường cong.
Các kiểu tô được định nghĩa bởi các phương thức thuộc đối tượng Paint. Lớp
Color có sắn trong các phiên bản trước của AWT đây là một dạng đơn giản của đối
tượng Paint được sử dụng để định nghĩa tô màu trơn (solid color). Java 2D API cung
cấp thêm hai phương thức mới cho Paint là TexturePaint và GradientPaint.
TexturePaint định nghĩa kiểu tô dùng mẩu ảnh đơn giản(simple image fragment ) mà
được lặp như nhau. GradientPaint định nghĩa một kiểu tô màu loang(gradient) giữa hai
màu.
Trong Java 2D, rendering một đường nét của một hình và tô hình đó bằng một kiểu
nào đó được thực hiên hai thao tác riêng biệt:
• Sử dụng một trong các thuật toán draw để render các đường nét của hình sử
dụng các kiểu bút được xác định bởi các thuộc tính của Stroke và kiểu tô được
xác định bởi thuộc tính Paint.
• Sử dụng phương thức fill để tô các vùng trong của hình với kiểu tô đã dược
xác định.
Khi một chuỗi kí tự được render,các thuộc tính hiện tại của Paint đựơc áp dụng
cho các glyphs tạo nên chuỗi đó.Lưu ý thực chất đối tượng drawString sẽ tô các glyphs
mà được render. Để vẽ các nét của các glyphs trong chuỗi kí tự cần phải chọn các
đường nét và render chúng như đối với các hình sử dụng phương thức draw .
1.2.6 Composites
Khi render một đối tượng mà chồng lên một đối tượng đã tồn tai trước đó cần phải
xác định làm thế nào để kết hợp màu của các đối tuợng. Java 2D API có các luật cho
việc kết hợp màu trong trường hợp này trong đối tượng Composite.

Tuy nhiên có một số vấn đề trong cách tiếp cận này:
• Sẽ thật khó trong trường hợp nếu màu Red và màu Blue được thêm vào hây
không được thêm vào.
• Việc kết hợp lôgíc sẽ không được hỗ trợ trong trường hợp cácmàu thuộc các
không gian màu khác nhau.
• Sự kết hợp sẽ không có ý nghĩa trong trường hợp màu được biểu diễn bằng các
gia trị màu thì khi đó sự kết hợp hai điểm ảnh là sự kết hợp của hai giá trị màu.
Java 2D API tránh các loĩi này bằng cách thực hiện các luật pha trộn alpha mà sẽ
đưa vào các thông tin về kiểu biểu diễn điểm ảnh mỗi khi thực hiện kết hợp màu. Một
đối tượng AlphaComposite bao gồm các kiểu về màu sắc của các màu sắc của nguồn
và đích.
13
Lập trình đồ họa trên Java 2D và 3D
Backward Compatibility and Platform independence
Như đã nói,Java 2D™ API có sự tương thích đối với phần mềm JDK 1.1 . Và Java
2D™ API là một kiến trúc chính vì vậy mà các ứng dụng của nó có tính độc lập về môi
trường
1.3.1 Backward Compatibility
Để tương thích với các tính năng đã tồn tại trong đồ họa JDK .Java 2D API tăng
cường thêm một số tính năng cho AWT bằng cách thêm các phương thức mới vào các
lớp đã tồn tại,mở rộng thêm các lớp đã tồn tại và đồng thời thêm các lớp mới và các
interface mới mà không ảnh hưởng tới các API hợp lệ.
Ví dụ,Có rất nhiều tính năng củaJava 2D API được bắt nguồn từ việc mở rộng các
thuộc tính về đồ họa trong Graphics2D. Để cung cấp các thuộc tính mở rộng về đồ
họa trong đó bao gồm cả yếu tố tương thích với các phần mềm đồ họa khác,
Graphics2D mở rộng các lớp Graphics trong JDK1.1.
• paint
• paintAll
• update
• print

• printAll
• getGraphics
JDK 1.1 applet thông dịch ngữ cảnh đồ họa mà được đưa vào như là một thể hiện
của lớp Graphics. Để có thể truy nhập những chức năng được thực thi trong đối tượng
Graphics2D, thì một applet tương thích với Java 2D API sẽ đưa ngữ cảnh đồ họa tới
đối tượng Graphics2D:
public void Paint (Graphics g) {
Graphics2D g2 = (Graphics2D) g;
...
...
g2.setTransform (t);
}
Trong môt vài trường hợp , hay đúng hơn là mở rộng một lớp thừa kế, Java 2D API
khái quat hóa nó. Có hai kĩ thuật đã được sử dụng để khái quat hóa các lớp kế thừa:
• Một hay nhiều lớp cha được chèn vào biểu đồ phân cấp của lớp , và các lớp thừa
kế được cập nhật để mở rộng các lớp cha mới. Kĩ thuật này được sử dụng để thêm các
phương thức và các dữ liệu thể hiện cho lớp kế thừa.
• Một hay nhiều triển khai các interface được thêm vào lớp kế thừa . Kĩ thuật này
được sử dụng để thêm các phương thức ảo tổng quát(general abstract methods) cho lớp
kế thừa .
Ví dụ, Java 2D API khái quát hóa lớp AWT Rectangle bằng cách sử dụng cả hai kĩ
thuật Sự phân cấp cho hình chữ nhật giống như:
14
Lập trình đồ họa trên Java 2D và 3D
Trong phần mềm JDK 1.1 , Rectangle là một đối tuợng mở rộng đơn giản. Bây giờ
mở rộng các lớp Rectangle2D mới và triển khai cả hai interface Shape và Serializable.
Hai lớp cha được thêm vào phân cấp của lớp Rectangle là RectangularShape và
Rectangle2D. Các Applet được viết cho phần mềm JDK 1.1 không truy cập được các
lớp mới và các phần triển khai của các interface,nhưng điều này không ảnh hưởng bởi
vì lớp Rectangle vẫn bao gồm các phương thức và các thành phần có trong các phiên

bản trước.
1.3.2 Platform independence
Có khả năng pháp triển các ứng dụng độc lập với môi trường. Java 2D API không
đảm đương về không gian màu sắc hay là chế độ màu của thiết bị rendering và Java 2D
API có bất kì định dạng ảnh cụ thể nào.
Và chỉ độc lập về font khi các font đó đã được xây dựng sẵn(được cung cấp như là
một phần của phần mềm JDK ),hay là khi chúng được gởi tạo bằng lập trình. Java 2D
API không hỗ trợ các font xây dựng sẵn và các font được tạo nên nhờ chương trình tạo
font nhưng nó lại hỗ trợ việc định nghĩa các font thông qua tập các glyph của nó. Mỗi
glyph lại có thể được định nghĩa bởi Shape mà bao gồm các đoạn đường thẳng và các
đường cong. Có rất nhiều kiểu font với nhiều hình dang và kich thước được bắt nguồn
từ tập các glyph đơn lẻ.
1.4 The Java 2D™ API Packages
Các lớp Java 2D API được tổ chức trong các package sau:
• java.awt
• java.awt.geom
• java.awt.font
• java.awt.color
• java.awt.image
• java.awt.image.renderable
• java.awt.print
Package java.awt bao gồm các lớp Java 2D API đã đề cập ở trên và các interface
đã tồn tại trước đó và các interface fát triển thêm. (Rõ dàng là không phải tất cả các lớp
trong java.awt là các lớp của Java 2D )
Package java.awt.geom bao gồm các classe và interface có liên quan đến việc định
nghĩa các dạng hình học nguyên thủy:
15
Lập trình đồ họa trên Java 2D và 3D

Có nhiều dạng hình học nguyên thủy ứng với các phần implementation. Float và

Double
Điều này cho phép các implementation có thể ở hai mức chính xác là giá trị single
và double.
Gói java.awt.font chứa các lớp và các giao diện được sử dụng cho việc bố trí văn
bản và định nghĩa các kiểu font:
Gói java.awt.color chứa các lớp và các giao diện cho việc định nghĩa các không gian
màu và các mẫu màu:
Các gói java.awt.image và java.awt.image.renderable chứa các lớp và các giao
diện cho việc định nghĩa và tạo bóng của ảnh.
16
Lập trình đồ họa trên Java 2D và 3D
Package java.awt.image tồn tại trong các version trước đó của AWT. Java 2D API
tăng cường thêm các lớp ảnh kế thừa từ AWT sau đây:
• ColorModel
• DirectColorModel
• indexColorModel
Các lớp chế độ màu sắc này vẫn tồn tại trong package java.awt.image package cho
sự tương thích .Để đảm bảo tính thống nhất,các lớp cho chế độ màu mới cũng có trong
package java.awt.image .
Package java.awt.print bao gồm các lớp và các interface cho phép in tất cả các
dạng văn bản ,đồ họa và ảnh dựa trên công nghệ Java 2D.
17
Lập trình đồ họa trên Java 2D và 3D
Chương 2:
Rendering with Graphics2D
Graphics2D mở rộng java.awt.Graphics để tạo ra điều khiển tinh vi hơn về biểu
diễn các hình ,văn bản và ảnh .Quá trình tô trát Java 2D™ được điều khiển thông qua
đối tượng Graphics2D và các thuộc tính trạng thái của nó.
Các thuộc tính tạng thái Graphics2D , như là các kiểu đường thẳng và các phép biến
đổi,được áp dụng cho các đối tượng đồ họa khi chúng được tô trát. Tập các thuộc tính

trạng thái kết hợp với Graphics2D được tham chiếu tới như là Graphics2DContext.
Để tô trát văn bản ,hình và ảnh,cần thiết lập Graphics2D context và sau đó gọi một
trong các phương thức tô trát Graphics2D như draw hay fill.
2.1 Các lớp và giao diện.
Bảng cho sau đây sẽ liêt kê các giao diện và lớp trong việc kết hợp với ngữ cảnh
Graphics2D context,bao gồm các lớp biểu diễn các thuộc tính trạng thái. Hầu hết các
lớp này là một phần của package java.awt.
Các giao diện và mô tả chúng:
Giao diện Mô tả
Composite Định nghĩa các phương thức cho việc kết hợp một đối tượng vẽ
gốc với cùng đồ họa được đánh dấu. Được thực thi bởi phương
thức AlphaComposite.
CompositeContext Định nghĩa một môi trương tối ưu và độc lập cho việc thực hiện
các phép kết hợp .Việc thực hiện các luật kết hợp tùy chọn được
thực hiện bơit người lập trình.
Paint Mở rộng: Transparency
Định nghĩa các màu sắc cho việc tô hoặc vẽ. Được thực thi bởi đối
tượng Color,Gradient-Paint và TexturePaint.
PaintContext Định nghĩa một môi trương tối ưu và độc lập cho việc vẽ.Các thao
tác vẽ được tùy chọn bởi người lập trình.
Stroke Tạo ra một đối tượng Shape mà các đường viền của nó đựoc tạo
bóng.Được thực thi bởi phương thức BasicStroke.
Các lớp và mô tả sơ lược về chúng:
18
Lập trình đồ họa trên Java 2D và 3D
Lớp Mô tả
AffineTransform
(java.awt.geom)
Miêu tả một phép biến đổi 2D affine ,mà thực hiện việc ánh xạ
tuyến tính từ tọa độ 2D này đến tọa độ 2D khác.

AlphaComposite Thực thi : Composite
Thực hiện các luật kết hợp các giá trị alpha cơ bản cho các đối
tượng Shape,Text và Image.
BasicStroke Thực thi :Stroke
Định nghĩa kiểu bút vẽ( “pen style”) được áp dụng cho các đường
bao của đối tượng Shape.
Color Thực thi: Paint
Định nghĩa một kiểu tô màu đồng nhất cho đối tượng Shape.
GradientPaint Thực thi: Paint
Định nghĩa một mẫu tô màu loang tuyến tính cho đối tượng
Shape.Mẫu này sẽ thay đổi từ màu C1 (tại điểm P1) tới màu C2(tai
điểm P2).
Graphics2D Mở rộng: Graphics
Lớp cơ sở cho quá trình tạo bóng trong không gian 2D.Mở rộng lớp
gốc java.awt.Graphics
TexturePaint Thực thi: Paint
Định nghĩa một kiểu tô theo mẫu cho đối tượng Shape.Mẫu tô được
tạo ra từu đối tượng BufferedImage.
2.2 Rendering Concepts
Để tô trát một đối tượng đồ họa sử dụng Java 2D™ API, cần thiết lập ngữ cảnh
Graphics2DContext và sử dụng một trong các phương thức tô trát Graphics2D đối
với đối tượng.
Có thể thay đổi các thuộc tính trạng thái mà tạo nên ngữ cảnh Graphics2D như :
• Thay đổi độ rộng của nét bút
• Thay đổi cho các nét bút kết hợp với nhau như thế nào.
• Thiết lập một khung cắt để giới hạn vùng được tô trát.
• Chuyển đổi tọa độ ,xoay,lấy tỉ lệ hoặc cắt cá đối tượng khi chúng được
render.
• Định nghĩa các màu và các kiểu để tô các hình.
• Xác định các đối tượng đa đồ họa(multiple graphics objects) cần phải được

tạo ra như thế nào.
Graphics2D định nghĩa một số phương thức để thêm và thay đổi các thuộc tính
trong ngữ cảnh đồ họa . Hầu hết những phương thức này là những đối tượng biểu diễn
các thuộc tính riêng biệt như đối tựơng Paint hay Stroke .
Ngữ cảnh Graphics2D cất giữ các tham chiếu tới các đối tương thuộc tính . Nếu biến
đổi một đối tượng thuộc tính mà là một phần của ngữ cảnh Graphics2D ,thì cần phải
gọi phương thức thiết lập phù hợp để khai báo ngữ cảnh.Thay đổi một đối tượng trong
quá trình thao tác render sẽ gây nên một số biểu hiện bất thương thường và không ổn
định .
2.2.1 Rendering Process
Khi một đối tượng đồ họa được render, thông tin về hình học ,ảnh và thuộc tính
được kết hợp để tính toán những giá trị điểm ảnh cần phải thay đổi trên màn hiển thị.
19
Lập trình đồ họa trên Java 2D và 3D
Quá trình render cho một đối tượng Shape có thể được chia thành 4 bước :
1. Nếu đối tượng Shape được taọ nét ,đối tượng Stroke quy vào ngữ cảnh
Graphics2D được sử dụng để tạo nên một đối tượng Shape mới bao quanh những
đường nét đó .
2. Tọa độ của đường thuộc đối tượng Shape được biến đổi từ không gian người sử
dụng sang không gian của thiết bị theo các thuộc tính biến đổi trong ngữ cảng đồ họa
Graphics2D .
3. Đường (path)của đối tượng Shape được cắt bỏ bằng cách sử dụng các thuộc tính
cắt trong ngữ cảnh Graphics2D.
4. Phần còn lại của đối tượng Shape được tô băng cách sử dụng thuộc tính của đối
tượng Paint và Composite thuộc tính trong ngữ cảnh của đối tượng Graphics2D.
Tạo bóng (Rendering) văn bản tương đương với việc tạo bóng các đối tượng thuộc
kiểu Shape, khi đó văn bản được tạo bóng với từng glyph và mỗi glyph là một đối
tượng thuộc kiểu Shape. Chỉ có điều khác là Java 2D API phải xác định đối tượng
Font nào sử dụng cho văn bản và lấy kiểu glyph tương ứng từ đối tượng Font trước
khi tạo bóng.

Đối với ảnh thì có sự khác biệt , sự chuyển đổi và thực hiện các phép cắt bỏ với
hộp xác định biên ảnh( image’s bounding box). Thông tin về màu sắc lấy từ chính ảnh
đó và nguồn alpha(alpha channel) được sử dụng kết hợp với thuộc tính hiện tại của
Composite khi các điểm ảnh được hợp trên bề mặt tạo bóng.
2.2.2 Controlling Rendering Quality
Java 2D API đưa ra các lựa chọn cho phép người sử dụng tạo bóng nhanh hay tạo
bóng với chất lượng cao. Những tham chiếu của người su dụng được xác định như là
các chỉ dẫn thông qua thuộc tính của đối tượng RenderingHints trong ngữ cảnh của
đối tượng Graphics2D . Không phải tất cả các môi trường đều hỗ trợ việc thay đổi chế
độ tạo bóng vì vậy xác định các chỉ dẫn cho quá trình tạo bóng sẽ không được đảm bảo
chúng sẽ được sử dụng hay không .
Lớp RenderingHints hỗ trợ cá kiểu chỉ dẫn sau đây:
• Alpha interpolation - có thể thiết lập tùy chọn default, quality, speed.
• Antialiasing - có thể thiết lập tùy chọn default :on hoặc off.
• Color Rendering - có thể thiết lập tùy chọn default, quality, hoặc speed.
• Dithering - có thể thiết lập tùy chọn default:disable, enable.
• Fractional Metrics - có thể thiết lập tùy chọn default, on, hoặc off.
• Interpolation- có thể thiết lập tùy chọn nearest-neighbor, bilinear, hoặc bicubic.
• Rendering - có thể thiết lập tùy chọn default, quality, hoặc speed.
• Text antialiasing - có thể thiết lập tùy chọn default: on hoặc off.
Để thiết lập hoặc thay đổi các thuộc tính RenderingHints trong ngữ cảnh của đối
tượng Graphics2D thì gọi phương thức setRenderingHints. Khi một chỉ dẫn được
thiết lập măc định ,môi trường tạo bóng mặc định sẽ được sử dụng .
Kĩ thuật làm trơn(Antialiasing)
Khi các thực thể cơ sở được tạo bóng trên thiết bị hiển thị ,các biên(cạnh) của
chúng có thể không trơn hay nhám là do thuộc tính aliasing. Các đường cung và đường
chéo có dạng nhám bởi vì chúng được xấp xỉ bởi các điểm ảnh mà gần nhất về hìn dạng
với chúng . Đây là điều mà chúng ta có thể nhận thấy với các thiết bị trước đây với các
cạnh nhám xuất hiện trái ngược hoàn toàn với các cạnh trơn của đườgn nằm ngang hay
thẳng đứng.

Antialiasing là một kĩ thuật được sử dụng để tạo bóng các đối tượng với các cạnh
trơn hơn. Thay vì sử dụng các điểm ảnh gẩn giống với các đường chéo và đường cong
20
Lập trình đồ họa trên Java 2D và 3D
,tăng mật độ các điểm ảnh bao quanh tới các vùng được tạo bóng. Điều này làm cho
cách cạnh trơn hơn và trải rộng sự chuyển tiếp bật/tắt với các pixel đa điểm(multi
pixel) . Tuy nhiên kĩ thuật antialiasing đòi hỏi nhiều về tài nguyên máy tính và làm tăng
thời gian tạo bóng.
2.2.3 Stroke Attributes
Tạo nét một đối tượng thuộc kiểu Shape như đối tượng GeneralPath tương
đươnng với việc sử dụng một bút lôgíc theo các đoạn của đối tượng GeneralPath.
Thuộc tính của Graphics2DStroke định nghĩa các tính chất của nét bút vẽ.
Đối tượng BasicStroke được sử dụng để định nghĩa các thuộc tính đường nét cho
một ngữ cảnh của Graphics2D. BasicStroke đinh nghĩa các thuộc tính như độ rộng cuả
nét vẽ ,mẫu tô…
Để thiết lập hay thay đổi các thuộc tính Stroke trong ngữ cảnh của Graphics2D thì
gọi phương thức setStroke.
Như ví du,ảnh đầu tiên trong hình 2-3 sử dụng miter join-style,và hình thứ hai sử
dụng kiểu round join-style, a round endcap style, and a dashing pattern.
Các phương thức tạo bóng Graphics2D có sử dụng thuộc tính của Stroke để vẽ
như drawArc, drawLine, drawOval, drawPolygon, drawPolyline, drawRect, và
drawRoundRect.Khi một trong các phương thức được gọi thì các đường nét của đối
tượng Shape đã xác định sẽ được tậo bóng. Thuộc tính Stroke định nghĩa các tính
chất của đường thẳng và các thuộc tính của Paint định nghĩa màu sắc hay mẫu của nét
bút. Ví dụ phương thức draw(myRectangle) được gọi:
1. Thuộc tính của Stroke sẽ quy định cho đường nét của hình chữ nhật .
2. Các đường nét này sẽ được biến đổi thành một đối tượng kiểu Shape .
3. Đối tượng Paint is được áp dụngcác điểm ảnh thuộc miền giới hạn bởi đường bao
của đối tựơng Shape.
Quá trình xử lý này được minh hạo trong hình 2-4:

21
Lập trình đồ họa trên Java 2D và 3D
2.2.4 Fill Attributes
Thuộc tính tô màu trong ngữ cảnh Graphics2D được biểu diễn bởi đối tượng
Paint. Có thể thêm một đối tượng vào ngữ cảnh của đối tượng Graphics2D
(Graphics2D context) bằng cách gọi phương thức setPaint.
Khi một đối tượng Shape hay là các glyph được vẽ (bởi các phương thức
Graphics2D.draw, Graphics2D.drawString),
Đối tượng Paint này sẽ được áp dụng tới tất cả các pixel nằm trong đối tượng
Shape mà biểu diễn các đường nét bao quanh đối tượng . Khi một đối tượng Shape
được tô màu (Graphics2D.fill), đối tượng Paint được áp dụng tới tất cả các điểm ảnh
nằm trong đường bao của đối tượng Shape.
Các kiểu tô màu đồng nhất đơn giản (solid color) được khởi tạo bởi phương thức
setColor.Color là phần triển khai (implementation) đơn giản nhất của giao tiếp Paint
(Paint interface).
Để tô các hình với các kiểu tô phức tạp hơn như là tô loang(gradient) và tô dệt
( texture) bằng cách sử dụng các lớp trong Java 2D Paint là GradientPaint và
TexturePaint. Các lớp này sẽ loại bỏ các công việc tiêu tốn thời gian để tạo các kiểu tô
phức tạp bằng cách sử dụng các kiểu tô mầu đồng nhất đơn giản .
Khi gọi phưong thức fill để tạo bóng một đối tượng Shape,thì hệ thống sẽ:
1. Xác định các điểm ảnh nào để thể hiện đối tượng đó.
2. Xác định màu cho mỗi điểm ảnh từ đối tựợng Paint.
3. Chuyển các màu này tới giá trị điểm ảnh tương ứng cho các thiết bị hiển thị.
4. Ghi các điểm ảnh ra thiết bị hiển thị đó.
Quá trình xử lý theo phiên
Để tổ chức hợp lý quá trình xử lý các điểm ảnh , Java 2D API tổ chức chúng theo
từng phiên.
22
Lập trình đồ họa trên Java 2D và 3D
Mỗi phiên có thể là tập các điểm ảnh kề nhau trên một đường quét hay là một khối

(block)các điểm ảnh. Quá trình xử lý theo phiên được thực hiện theo 2 bước:
1. Phương thức createContext của đối tượng paint được gọi để tạo một đối tượng
PaintContext. Đối tượng PaintContext này sẽ lưu thông tin ngữ cảnh về thao tác tạo
bóng hiện thời và những thông tin cần thiết để tạo ra các màu. Phương thức
createContext method is passed the bounding boxes of thegraphics object being filled in
user space and in device space,đối tượng ColorModel là nơi để tạo các màu sắc,và thực
hiện quá trình chuyển đổi để ánh xạ từ không gian người sử dụng vào không gian của
thiết bị. Đối tượng ColorModel xem như một chỉ dẫn không phải tất cả các đối tượng
Paint có thể hỗ trợ một đối tượng ColorModel bất kỳ.
2. Phương thức getColorModel được gọi để nhận giá trị của đối tượng
ColorModel cho màu vẽ từ đối tượng PaintContext.
Phương thức getRaster sau đó được gọi lặp lại nhiều lần để nhận giá trị của đối
tựợng Raster mà bao gồm dữ liệu màu thật cho mỗi phiên. Thông tin này passed to the
next stage in the rendering pipeline, mà vẽ các màu đã được tạo bằng cách sử dụng đối
tựợng Composite hiện thời .
2.2.5 Clipping Paths
Một khung nhìn sẽ xác định phần của đối tượng Shape hay Image cần được tạo
bóng . Khi một khung nhìn là một phần của ngữ cảnh của đối tượng Graphics2D, thì
chỉ những phần của đối tượng Shape hay image nằm trong khung nhìn đó mới được
tạo bóng.
Để thêm khung nhìn cho ngữ cảnh của Graphics2D thì goị phương thức setClip.
Bất kì đối tượng Shape cũng có thể được sử dụng để định nghĩa một khung nhìn.
Để thành đổi khung nhìn cần phải sử dụng phương thức setClip để xác định một
khung nhìn mới hay là gọi phương thức clip để thay đổi khung nhìn cho phần giao nhau
giữa khung nhìn cũ và một đối tượng Shape.
2.2.6 Transformations
Ngữ cảnh của đối tượng Graphics2D bao gồm một phép bién đổi mà được sử
dụng để biến đổi những đối tượng từ không gian người sử dụng vào không gian thiết bị
trong quá trình tạo bóng. Để thực hiện các phép biến đổi khác như phép quay hay lấy tỉ
lệ thì cần phải thêm các phép biến đổi khác vào ngữ cảnh của đối tượng.Các phép biến

đổi được thêm vào này sẽ trở thành một phần của ống biến đổi (pipeline of
transformations) mà được ápdụng trong suôt qua trình tạo bóng.
Graphics2D cung cấp một vài cách khác để thay đổi phép biến đổi trong ngữ cảnh
của đối tượng Graphics2D . Cách đơn giản nhất là gọi một trong các phương thức biến
đổi trong đối tượng Graphics2D như : rotate, scale, shear, hay translate. Xác định các
tính chất của phép biến đổi để áp dụng trong suốt qúa trình tạo bóng và Graphics2D tự
động tạo ra các thay đổi phù hợp.
Cũng có thể nối một phép biến đổi AffineTransform với phép biến đổi
Graphics2D hiện tại. Phép biến đổi AffineTransform thực hiện các phép biến đổi cho
đường như phép dịch,tỉ lệ ,quay và cắt bỏ với tập các hình cơ bản.
Khi một phép biến đổi được nối vào phép biến đổi đã tồn tại trước đó thì phép biến
đổi sau cùng sẽ được xác định như là phép biến đổi được thực hiện đầu tiên. Để tiếp nối
một phép biến đổi với phép biến đổi hiện tại , you pass an AffineTransform to
Graphics2D.transform.
Lớp Graphics2D cũng bao gồm phương thức setTransform , nhưng phương thức
này không bao giờ được sử dụng để nối với các phép biến đổi tọa độ khác của phép
biến đổi đang tồn tại. Phương thức setTransform sẽ ghi đè lên phép biến đổi hiện thời
23
Lập trình đồ họa trên Java 2D và 3D
của đối tượng Graphics2D, nhưng phương thức này cần cho môt số mục đích khác
như:
• Áp dụng phép biến đổi tỉ lệ điều chỉnh cho máy in.
• Vẽ một đối tượng JComponent non-zero translation from its parent’s origin
• Phóng to một thành phần để dễ dàng quan sát.
• Các tình huống khác mà người cung cấp đối tượng Graphics2D muốn chuyển đổi
cho quá trình tạo bóng hiệu quả .
Phương thức setTransform method được xem như để thiết lập đối tượng
Graphics2D trở lai phép biến đổi ban đầu sau quá trình tạo bóng đồ họa ,văn bản và
ảnh đã được chuyển đổi:
AffineTransform

aT

=

g2d.getTransform();
g2d.transform(...);
g2d.draw(...);
g2d.setTransform(aT);
Graphics2D cũng cung câp một phiên bản về drawimage mà trong đó đối tượng
AffineTransform
Được xem như một tham số . Điều này cho phép áp dụng một phép biến đổi cho
đối tượng ảnh khi nó được vẽ mà không cần chỉnh sửa đường ống cuả phép biến đổi.
Ảnh này được được vẽ như khi kết nối phép biến đôit này với phép biến đôit hiện tại
trong ngữ cảnh của Graphics2D
Các phép biến đổi quan hệ(Affine Transforms)
Java 2D API cung cấp một lớp biến đổi là AffineTransform. AffineTransforms
được sử dụng để biến đổi văn bản ,hình và các ảnh khi chúng được tạo bóng.
Cũng có thể ứng dụng các phép biến đổi cho đối tượng Font để tạo ra các dẫn xuất
font mới(new font derivations).
Một phép biến đổi đồng nhất (affine transformation) thực hiện một phép biến đổi tuyến
tính trên tập đồ hạo cơ bản. Nó luôn biến các đường thẳng thành các đường thẳng và
các đường thẳng song song thành các đường thẳng song song,tuy nhiên khoảng cách
giữa các điểm và các góc của các đường thẳng không song song có thể thay đổi.
Các phép biến đổi có thể kết hợp để tạo ra đường ống các phép biến đổi một cách
hiệu quả nhằm áp dụng cho một đối tượng nào đó. Sự kết hợp này xem như là sự móc
nối. Khi một phép biến đổi được kết nối với một phép biến đổi đang tồn tại như với
AffineTransform.concatenate, thì phép biến đổi cuối cùng được xác định là phép biến
đổi đầu tiên được áp dụng . Một phép biến đổi cũng có thể được móc nối trước với một
phép biến đổi đang tồn tại . Trong trường hợp này thì phép biến đổi cuối cùng sẽ được

thực hiện cuối cùng . Phép móc nối trước được được áp dụng để thực hiện các phép
biến đổi có liên quan với không gian thiết bị thay vì không gian người sử dụng. Ví dụ
có thể sử dụng phương thức AffineTransform.preConcatenate để thực hiện phép
chuyển đổi có liên quan tới không gian các điểm ảnh..
2.2.6.1 Constructing an AffineTransform
AffineTransform cung cấp một tập các phương thức cho việc xây dựng các đối
tượng AffineTransform.
•
getTranslateinstance
•
getRotateinstance
•
getScaleinstance
•

getShearinstance
24
Lập trình đồ họa trên Java 2D và 3D
Để sử dụng các phương thức này cần phải xác định các tính chất của phép biến đổi
mà cần tạo ra và lớp AffineTransform sẽ tạo ra các ma trận chuyển đổi phù hợp. Cũng
có thể xây dựng phép biến đổi đòng nhất một cách trực tiếp mà không cần thông qua
lớp AffineTransform bằng cách xác định các thành phần của phép biến đổi đó.
2.2.7 Composite Attributes
Khi hai đối tượng đồ họa trồng lên nhau thì điều cần thiết là phải xác định những
màu nào sẽ được tạo bóng cho các điểm ảnh chồng lên nhau. Ví dụ nếu một hình chữ
nhật màu đỏ và một hình chữ nhật màu xanh chồng lên nhau thì các điểm ảnh đó sẽ có
màu đỏ hoặc màu xanh hay là sự kết hợp của cả hai màu. Màu của những điểm ảnh
trong vùng chồng nhau đó sẽ xác định hình chữ nhật nào nằm trên và bị che khuất như
thế nào. Quá trình xử lý để xác định màu nào tạo bóng cho các điểm ảnh sẽ được chia
sẽ cho các đối tượng chồng (overlaping objects)được gọi compositing.

Có hai interface tạo các kiểu kết hợp cơ bản trong Java 2D là : Composite và
CompositeContext.
Để xác định các kiểu kết hợp sẽ được sử dụng thì cần phải thêm vào một đối tượng
AlphaComposite cho ngữ cảnh của đối tượng Graphics2D bằng cách gọi phương
thức setComposite. AlphaComposite,và một triển khai(implementation) của interface
Composite , có hỗ trợ một số kiểu kết hợp khác nhau . Mỗi đối tượng của lớp này là
một luật kết hợp để mô tả sự pha trộn một màu mới với màu đang tồn tại..
Một trong những luật kết hợp trong lớp AlphaComposite là SRC_OVER, luật này chỉ
ra màu mới (màu nguồn) sẽ được pha trộn với màu đang tồn tại (màu đích ) như thế
nào.
2.2.7.1 Managing Transparency
Giá trị alpha của một màu là giá trị đo đọ trong suôt của màu đó ,nó chỉ ra (theo
phần trăm) bao nhiêu phần trăm màu trước khi tô được hiển thị ra khi các màu chồng
lên nhau. Các màu tối (co giá tri alpha=1.0) thì các màu tô đè lên chúng sẽ không được
hiển thị, trong khi đó các màu trong suốt (có giá trị alpha=0.0) cho phép các màu tô đè
lên nó được hiển thị.
Khi văn bản và hình được tạo bóng thì giá trị alpha sẽ bắt nguồn từ thuộc tính của
đối tượng Paint trong ngữ cảnh của đối tượng Graphics2D . Khi các hình và văn bản
được làm trơn thì giá trị alpha từ thuộc tính Paint (trong ngữ cảnh của Graphics2D)
được kết hợp với thông tin về các điểm ảnh bị che từ “rasterized path”. Các ảnh lưu
thông tin về giá trị alpha của chính nó .
Khi tạo một đối tượng AlphaComposite , có thể xác định được giá trị alpha được
thêm vào . Khi thêm đối tượng AlphaComposite này tới ngữ cảnh của Graphics2D
25