Lời Cảm Ơn
Lời Cảm Ơn
(cid:87) (cid:88) Luận văn của chúng em sẽ rất khó hoàn thành nếu không có sự truyền đạt kiến
thức quí báu và sự hướng dẫn tận tình của Thầy Dương Anh Đức. Chúng em xin chân
thành cám ơn sự chỉ bảo của các thầy.
Chúng con xin gửi tất cả lòng biết ơn, sự kính trọng đến ông bà, cha mẹ, cùng
toàn thể gia đình, những người đã nuôi dạy, đã cho chúng con niềm tin và nghị lực để
vượt qua mọi khó khăn.
Chúng em xin trân trọng cám ơn quý Thầy cô trong Khoa Công nghệ thông tin
trường Đại học Khoa học Tự nhiên Tp.Hồ Chí Minh đã tận tình giảng dạy, truyền đạt
những kiến thức quý báu và tạo điều kiện cho chúng em được thực hiện luận văn này.
Xin chân thành cám ơn sự giúp đỡ, động viên và chỉ bảo rất nhiệt tình của các
anh chị đi trước và tất cả bạn bè. Các anh chị, các bạn luôn có mặt trong những thời
điểm khó khăn nhất, tiếp thêm động lực và ý chí, giúp chúng tôi hoàn thành được luận
văn.
Mặc dù đã cố gắng nỗ lực hết sức mình, song chắc chắn luận văn không khỏi
còn nhiều thiếu sót. Chúng em rất mong nhận được sự thông cảm và chỉ bảo tận tình
của quý Thầy cô và các bạn.
Tp.HCM, 7/2004
Nhóm sinh viên thực hiện
Trang 1
Nguyễn Quý Minh – Phạm Anh Vũ
Lời nói đầu
Lời Nói Đầu (cid:91) (cid:92)
Ngày nay, trong tất cả các lãnh vực của đời sống kinh tế, xã hội, công nghệ
thông tin được xem là một trong những ngành công nghệ mũi nhọn, đóng vai trò hết
sức quan trọng, có thể tạo ra những bước đột phá mạnh mẽ.
Các ứng dụng GIS ngày càng phát huy vai trò quan trọng trong việc hỗ trợ quản
lý, qui hoạch đặc biệt là đối với các tổ chức, chính phủ. Vấn đề qui hoạch ở Việt Nam,
cũng như ở nhiều quốc gia khác, đang gặp rất nhiều khó khăn, tốn nhiều thời gian và
tiền bạc, nhất là đối với các thành phố lớn, trọng điểm như TP Hồ Chí Minh, Hà Nội,
Hải Phòng ... Giải pháp cần thiết là một ứng dụng GIS hỗ trợ. Việc bắt tay xây dựng từ
đầu một ứng dụng GIS cần rất nhiều thời gian, tiền bạc và công sức nhưng chưa chắc
thành công. Trên thị trường cũng có những ứng dụng GIS thương mại, cho phép xây
dựng ứng dụng trên nền thư viện cung cấp sẵn như ArcView GIS, ArcGIS .. , tuy nhiên
sẽ phải đối mặt với vấn đề bản quyền, tốn rất nhiều tiền bạc khi triển khai trên diện
rộng.
GRASS là một phần mềm GIS có chức năng, sức mạnh bằng hoặc vượt các sản
phẩm thương mại nhưng điều đặc biệt là một ứng dụng mã nguồn mở, tức người sử
dụng có thể tự mình tòan quyền cài đặt, sữa chữa phù hợp với nhu cầu và đặc điểm
riêng của mình mà không phải trả chi phí bản quyền phần mềm. Điều hạn chế hiện nay
là GRASS chỉ được phát triển trên nền UNIX. Nếu có thể chuyển đổi GRASS sang
Windows, ta có thể xây dựng được nhiều ứng dụng GIS với chi phí rẻ, phù hợp để phổ
biến trên diện rộng do Windows là hệ điều hành dễ sử dụng, thân thiện và có số lượng
người dùng nhiều nhất hiện nay.
Với ý tưởng trên, chúng em đã tập trung thực hiện đề tài “NGHIÊN CỨU
Trang 2
CHUYỂN ĐỔI PHẦN MỀM GRASS TỪ NỀN UNIX LÊN WINDOWS”.
Lời nói đầu
Nội dung của luận văn được chia làm 5 chương:
Chương 0: Mở đầu giới thiệu chung về đề tài, ý nghĩa và các mục tiêu của đề
tài; trình bày các giải pháp và hướng nghiên cứu đã được thực hiện trong và ngoài
nước.
Chương 1: .OpenGIS – Khái niệm chung và Các mô hình dữ liệu, giới thiệu
chung về các khái niệm GIS, OpenGIS, các mô hình dữ liệu trên GIS.
Chương 2: Hệ Thống Hỗ trợ Phân tích Tài nguyên Địa lý, trình bày về phần
mềm mã nguồn mở GRASS, cách thức cài đặt và khởi tạo, cách thức sử dụng và lập
trình trên GRASS.
Chương 3: Quá trình chuyển đổi GRASS từ Unix lên môi trường Window,
các kỹ thuật cài đặt trong GRASS, mô hình và cấu trúc chi tiết của GRASS, các bộ thư
viện trung tâm.
Chương 4: Tổng kết tóm tắt lại các vấn đề đã được đặt ra trong luận văn, cách
Trang 3
giải quyết, kết quả đạt được và đề ra một số hướng phát triển trong tương lai.
Mục lục
Mục Lục
Lời Cảm Ơn ................................................................................................................................ 1 Lời Nói Đầu ................................................................................................................................ 2 Mục Lục...................................................................................................................................... 4 Danh sách các hình vẽ ................................................................................................................ 6 Chương 0 : Mở Đầu .................................................................................................................... 7 Chương 1 : OpenGIS – Khái niệm chung và Các mô hình dữ liệu .......................................... 8 1.1 Giới thiệu về GIS .............................................................................................................. 8 1.1.1 Định nghĩa GIS .......................................................................................................... 8 1.1.2 Các thành phần của GIS........................................................................................... 10 1.1.3 Các mô hình dữ liệu của GIS.................................................................................. 11 1.1.4 Vấn Đề Dữ Liệu Đối Với GIS ................................................................................. 12 1.2 Khái Quát Về OpenGIS .................................................................................................. 14 1.2.1 Tổ chức OGC........................................................................................................... 14 1.2.2 Định nghĩa OpenGIS ............................................................................................... 16 Chương 2 : Hệ Thống Hỗ trợ Phân tích Tài nguyên Địa lý..................................................... 17 2.1 Sơ lược về GRASS ......................................................................................................... 17 2.2 Kiến trúc GRASS............................................................................................................ 19 2.3 Định dạng dữ liệu .......................................................................................................... 20 2.4 Tổ chức lưu trữ dữ liệu của GRASS............................................................................... 23 2.4.1 GISDBASE :............................................................................................................ 23 2.4.2 LOCATION :........................................................................................................... 23 2.4.3 MAPSETS ............................................................................................................... 24 2.4.4 REGION và MASK ................................................................................................ 29 2.4.5 Các biến môi trường sử dụng trong GRASS ........................................................... 31 2.5 Dữ liệu RASTER ............................................................................................................ 32 2.5.1 Ý niệm sơ lược......................................................................................................... 32 2.5.2 Hệ thống tập tin raster............................................................................................. 34 2.5.3 Các thao tác quan trọng ........................................................................................... 34 2.6 Dữ liệu VECTOR (VECTOR DATA)............................................................................ 35 2.6.1 Ý niệm sơ lược......................................................................................................... 35 2.6.2 Hệ thống tập tin vector............................................................................................ 36 2.6.3 Các thao tác quan trọng ........................................................................................... 37 2.7 Dữ liệu điểm (POINT/SITE DATA) .............................................................................. 38 2.7.1 Ý niệm sơ lược......................................................................................................... 38 2.7.2 Hệ thống tập tin site ................................................................................................ 39 2.7.3 Các thao tác quan trọng ........................................................................................... 40 2.8 Các thư viện được cung cấp bởi GRASS (src/libes)....................................................... 41 2.8.1 Danh sách................................................................................................................. 41 2.8.2 Giới thiệu sơ bộ hàm và thư viện............................................................................. 43 2.9 Cơ chế bổ sung và quản lý mã nguồn của GRASS......................................................... 95
Trang 4
Mục lục
2.9.1 Mã nguồn chính thức (thư mục src)......................................................................... 96 2.9.2 Mã nguồn ALPHA (thư mục src.alpha)................................................................... 96 2.9.3 Mã nguồn đóng góp (thư mục src.contrib) .............................................................. 96 2.9.4 Mã nguồn có liên quan (thư mục src.related) .......................................................... 97 2.9.5 Mã nguồn GARDEN (src.garden) ........................................................................... 97 2.9.6 Các script (src/script/shell) ...................................................................................... 97 2.10 Hướng dẫn cài đặt và sơ lược cách sử dụng ................................................................. 97 2.10.1 Cài đặt GRASS trên LINUX ................................................................................. 97 2.10.2 Cài đặt GRASS trên Windows thông qua giả lập Cygwin .................................... 99 Chương 3 : Quá trình chuyển đổi GRASS5 từ Linux lên Windows..................................... 101 3.1 Sự khác biệt giữa Windows và Unix/Linux.................................................................. 101 3.1.1 Tổng quan về hệ điều hành Windows.................................................................... 101 3.1.2 Tổng quan về hệ điều hành UNIX ......................................................................... 103 3.1.3 So sánh tổng quát về lập trình đa nhiệm trên hai môi trường................................ 105 3.1.4 So sánh về hệ thống file của hai môi trường ......................................................... 109 3.1.5 Giao diện người dùng ............................................................................................ 112 3.1.6 Shell và script......................................................................................................... 113 3.2 Sơ lược về phần mềm GRASS ..................................................................................... 113 3.3 Sơ lược về mã nguồn của GRASS 5.0.2....................................................................... 114 3.4 Môi trường sử dụng để chuyển đổi GRASS5 ............................................................... 115 3.5 Các vấn đề chính khi chuyển đổi lên Windows........................................................... 116 3.5.1 Khởi tạo các biến môi trường cần thiết................................................................. 116 3.5.2 Dữ Liệu GRASS và Cấu trúc của dữ liệu GRASS ............................................... 119 3.5.3 Cấu trúc chung của source code GRASS.............................................................. 121 3.5.3.1 Cài đặt bộ thư viện trung tâm ............................................................................. 122 3.5.3.2 Cài đặt các nhóm lệnh xử lý của Grass............................................................... 124 3.5.3.3 Các Driver dùng để hiển thị của Display............................................................ 129 3.5.3.4 Cơ chế SendMessage trong GRASS5................................................................ 132 3.5.3.5 Khái niệm hệ thống đồ họa XWindow trong Linux .......................................... 143 3.5.3.6 Cài đặt và sử dụng các hàm X (Xlib) trên Window32....................................... 147 Chương 4 : Tổng Kết .............................................................................................................. 152 4.1 Kết Luận ....................................................................................................................... 152 4.2 Hướng Phát Triển ......................................................................................................... 152 Tài Liệu Tham Khảo............................................................................................................... 153 Phụ Lục ................................................................................................................................... 154
Trang 5
Danh sách các hình vẽ
Danh sách các hình vẽ
Hình 1 - 1 Minh họa về GIS ..................................................................................... 11 Hình 2 - 1 Mô hình kiến trúc GRASS ...................................................................... 20 Hình 2 - 2 Minh họa cấu trúc lưu trữ của GISDBASE trên đĩa................................ 23 Hình 2 - 3 Minh họa cấu trúc lưu trữ của LOCATION trên đĩa............................... 24 Hình 2 - 4 Minh họa cấu trúc lưu trữ của MAPSET trên đĩa.................................... 25 Hình 2 - 5 Minh họa cơ chế MASK của GRASS ..................................................... 31 Hình 2 - 6 Minh họa dữ liệu điểm – POINT/SITE ................................................... 39 Hình 2 - 7 Hình ảnh sử dụng GRASS5 trên Linux................................................... 99 Hình 2 - 8 Hình ảnh sử dụng GRASS5 trên Windows thông qua giả lập Cygwin. 100 Hình 3 - 1 Kiến trúc của hệ điều hành Windows theo họ NT................................ 103 Hình 3 - 2 Các dòng hệ điều hành phát triển trên nền UNIX ................................ 104 Hình 3 - 3 Kiến trúc của hệ điều hành UNIX ........................................................ 105 Hình 3 - 4 Mô hình minh họa cơ chế Send Event trong GRASS5 ........................ 138 Hình 3 - 5 Kiến trúc thư viện XLIB....................................................................... 151
Trang 6
Chương 0: Mở đầu
Chương 0 : Mở Đầu
Các ứng dụng GIS ngày càng phát huy vai trò quan trọng trong việc hỗ trợ quản
lý, qui hoạch đặc biệt là đối với các tổ chức, chính phủ. Vấn đề qui hoạch ở Việt Nam,
cũng như ở nhiều quốc gia khác, đang gặp rất nhiều khó khăn, tốn nhiều thời gian và
tiền bạc, nhất là đối với các thành phố lớn, trọng điểm như TP Hồ Chí Minh, Hà Nội,
Hải Phòng ... Giải pháp cần thiết là một ứng dụng GIS hỗ trợ. Từ nhu cầu nói trên,
chúng em đã đầu tư xây dựng đề tài “NGHIÊN CỨU CHUYỂN ĐỔI PHẦN MỀM
GRASS TỪ NỀN UNIX LÊN WINDOWS”.
Đề tài phải giải quyết một số công việc chính:
Nghiên cứu GIS và chuẩn OpenGIS. •
Nghiên cứu sự khác nhau giữa hệ điều hành Unix và Windows. •
Dựa vào những hiểu biết này, xem xét việc xây dựng một ứng dụng GIS •
trên nền phần mềm mã nguồn mở GRASS.
Triển khai việc chuyển đổi GRASS từ môi trường Unix sang môi trường •
Trang 7
Windows.
Chương 1: OpenGis – Các khái niệm
Chương 1 : OpenGIS – Khái niệm chung và Các mô hình dữ liệu
Chương này trình bày khái quát về GIS và những vấn đề tồn tại liên quan đến trao đổi
dữ liệu GIS trong môi trường mạng dẫn đến nhu cầu xuất hiện OpenGIS. Các khái
niệm và chủ đề liên quan đến OpenGIS, vai trò của tổ chức OGC (Open GIS
Consortium), mô hình tham chiếu ORM (OpenGIS Refrerence Model), và các bộ đặc
tả về OpenGIS được đề xuất bởi OGC là những phần chính được đề cập đến trong
chương này.
1.1 Giới thiệu về GIS
1.1.1 Định nghĩa GIS
Hệ thống thông tin địa lý, gọi tắt là GIS (Geographic Information System) ra đời từ đầu
thập niên 60. Tuy nhiên mãi đến thập niên 80, GIS mới thực sự được phát triển nhanh
chóng. Cho đến nay, tuỳ theo cách tiếp cận mà người ta có nhiều định nghĩa khác nhau
về GIS. Những định nghĩa này bổ sung cho nhau giúp ta hiểu đầy đủ hơn các khía cạnh
của GIS. Sau đây là một số định nghĩa của GIS được trích theo Peter & Rachael
(1998):
GIS là một tập các công cụ mạnh dùng cho việc thu nhập, lưu trữ cũng như •
truy tìm, biến đổi và hiển thị các dữ liệu không gian từ thế giới thực (Burrough,
1986)
GIS là một hệ thống dùng cho việc nắm bắt, kiểm tra, thao tác, phân tích và •
hiển thị các dữ liệu qui chiếu không gian liên quan đến Trái đất (Department of
Environment, 1987)
Trang 8
GIS là công nghệ thông tin cho phép lưu trữ, phân tích, và hiển thị cả dữ liệu •
Chương 1: OpenGis – Các khái niệm
không gian lẫn dữ liệu phi không gian (Parker, 1988)
GIS là hệ thống cơ sở dữ liệu trong đó phần lớn dữ liệu biểu thị không gian, và •
tập các thủ tục thao tác trên những dữ liệu này nhằm trả lời những truy vấn về
các thực thể không gian chứa trong cơ sở dữ liệu (Smith et al,. 1987)
GIS là tập các thủ tục thủ công hoặc dựa trên máy tính được dùng để lưu trữ và •
thao tác các dữ liệu tham chiếu địa lý (Aronoff, 1989)
GIS là tập các chức năng được thực hiện một cách tự động nhằm cung cấp •
những năng lực cấp cao đối với sự lưu trữ, truy tìm, thao tá và hiển thị các dữ
liệu vị trí địa lý (Ozemoy, Smith, & Sicherman, 1981)
GIS là một thực thể tổ chức, phản ánh cấu trúc tổ chức cho phép tích hợp công •
nghệ với cơ sở dữ liệu và các chuyên gia, và tổ chức này liên tục hỗ trợ tài
chính (Carter, 1989)
GIS là hệ thống hỗ trợ quyết định liên quan đến sự tích hợp dữ liệu quy chiếu •
không gian trong một môi trường giải quyết vấn đề (Cowen, 1988)
Thông qua các định nghĩa trên, ta thấy được ba khía cạnh quan trọng của một •
hệ thống GIS bao gồm:
Tập các công cụ hoặc thủ tục cho phép thực hiện các chức năng lưu trữ, truy •
tìm, biến đổi, phân tích và hiển thị dữ liệu không gian địa lý.
Cơ sở dữ liệu là thành phần quan trọng chức các dữ liệu không gian kết hợp dữ •
liệu phi không gian.
Tổ chức nhằm phối hợp kỹ thuật và con người để có thể duy trì và phát triển hệ •
Trang 9
thống nhằm đưa ra những quyết định hợp lý.
Chương 1: OpenGis – Các khái niệm
1.1.2 Các thành phần của GIS
Có nhiều mô hình GIS tuỳ theo nhu cầu của người dùng. Mô hình đầy đủ của GIS bao
gồm sáu thành phần: phần cứng, phần mềm, dữ liệu, qui trình, con người và tổ chức.
Những thành phần này cần phải kết hợp cân đối nhau để hệ thống làm việc hiệu quả.
Phần cứng GIS bao gồm hệ thống máy tính hoặc mạng máy tính cho phép •
nhập, xuất, lưu trữ, truyền và hiển thị dữ liệu không gian.
Phần mềm GIS bao gồm những công cụ thực hiện năm chức năng chính là •
nhập và kiểm tra dữ liệu, lưu trữ quản lý dữ liệu, xuất và thể hiện dữ liệu, biến
đổi phân tích dữ liệu, và giao tiếp với người sử dụng.
Dữ liệu GIS bao gồm dữ liệu không gian và dữ liệu phi không gian với dung •
lượng rất lớn, cần được thu nhập và lưu trữ theo một cấu trúc chuẩn để thuận
tiện cho việc trao đổi và bảo quản.
Các qui trình xử lý được xác lập trong quá trình phân tích và thiết kế hệ thống •
GIS cho một tổ chức với các mục tiêu cụ thể. Khả năng xây dựng và triển khai
các qui trình ảnh hưởng đến tính hữu hiệu của hệ thống GIS.
Con người là yếu tố quyết định sự thành công của hệ thống GIS. Con người •
bao gồm các kỹ thuật viên, chuyên viên công nghệ thông tin, nhà quản trị hệ
thống và người sử dụng các kết quả của GIS để ra quyết định.
Tất cả những thành phần trên cần được đặt trong một tổ chức thích hợp, có các •
Trang 10
cơ chế, chính sách và qui trình hợp lý.
Chương 1: OpenGis – Các khái niệm
Hình 1 - 1 Minh họa về GIS
1.1.3 Các mô hình dữ liệu của GIS
Trong GIS, các thực thể trong thế giới thực có thể được biểu diễn bằng những mô hình
dữ liệu khác nhau nhằm mô tả các thuộc tính, vị trí, thời gian và quan hệ không gian
giữa chúng. Các thực thể khi được biểu diễn trong mô hình dữ liệu thường được gọi là
các đối tượng. Để biểu diễn vị trí và quan hệ của các đối tượng trong không gian địa lý,
người ta dùng mô hình vector hoặc mô hình raster. Mô hình phân cấp, mô hình mạng
hoặc mô hình quan hệ thì được dùng để biểu diễn các thuộc tính của các đối tượng.
Trong cơ sở dữ liệu địa lý, các thuộc tính sẽ được liên kết với các đối tượng tương ứng
trong mô hình vector hoặc raster. Mỗi một mô hình đều có ưu điểm và nhược điểm
riêng, và có thể có nhiều cấu trúc dữ liệu, mỗi cấu trúc dữ liệu có thể được lưu trữ bằng
Trang 11
nhiều định dạng khác nhau.
Chương 1: OpenGis – Các khái niệm
Mô hình vector
Trong mô hình vector, mỗi đặc trưng địa lý trên mặt đất được xác định bằng những
điểm, đường và vùng trong mặt phẳng toạ độ Descartes. Mỗi điểm được xác định bởi
cặp toạ độ (x,y), mỗi đường được tuyến tính hoá thành nhiều đoạn biểu diễn bằng một
chuỗi những cặp toạ độ (xi, yi), mỗi vùng được xác định bởi một đường khép kính và
được biểu diễn bằng một chuỗi các cặp tọa độ (xi, yi) có các tọa độ điểm đầu và điểm
cuối trùng nhau.
Mô hình raster
Trong mô hình raster, không gian được chia thành những phần tử nhỏ còn được gọi là
tế bào. Mỗi tế bào được xem như đồng nhất, cùng một thuộc tính và được biểu diễn
như một điểm. Kích thước của mỗi tế bào được đặc trưng bởi độ phân giải.Có thể hình
dung dữ liệu raster như là một tấm lưới phủ lên một địa thế nào đó trong thế giới thực,
và mỗi ô trong lưới có một mã số đặc trưng cho một ý nghĩa nào đó của vùng nằm bên
trong ô đó.
Một đặc điểm của cấu trúc raster là một lưới raster như vậy chỉ biểu diễn được một
thuộc tính àno đó của đối tượng thôi, vì mỗi tế bào trong lưới chỉ được gán bởi duy
nhất một giá trị thuộc tính. Do vậy, người ta thường tạo nhiều lớp lưới raster khác nhau
để biểu diễn nhiều thuộc tính cho cùng một đối tượng, mỗi lớp cho mỗi thuộc tính.
1.1.4 Vấn Đề Dữ Liệu Đối Với GIS
Hiện nay trên thị trường có rất nhiều sản phẩm phần mềm GIS. Một số phần mềm GIS
được xây dựng trên mô hình dữ liệu vector (mô hình thông dụng), một số khác xây
dựng trên mô hình raster, và một số khác nữa xây dựng trên cả hai mô hình. Với mỗi
mô hình được chọn, các hãng sản xuất phần mềm GIS lại có những biễu diễn vật lý
Trang 12
riêng của mình ở thiết kế bên trong nhằm tối ưu hóa việc lưu trữ, xử lý cũng như hiển
Chương 1: OpenGis – Các khái niệm
thị dữ liệu. Bên cạnh đó, các tổ chức cũng đưa ra những dạng thức riêng của họ để
thuận tiện cho việc ghi nhận và trao đổi dữ liệu địa lý của tổ chức.
Để lưu trữ dữ liệu không gian địa lý theo kiểu vector, phần mềm GIS ArcInfo dùng
dạng thức tập tin .shp, AutoCAD dùng .dwg, Autodesk Map dùng .dxf, MapInfo dùng
.mif, MicroStation dùng .dng, … Còn tổ chức US Geological Survey dùng dạng thức
DLG (Digital Line Graph), Chính phủ US dùng SDTS (Spatial Data Transfer System),
tổ chức US Census Bureau dùng TIGER (Topologically Integrated Geographic
Encoding and Referencing Files), … (có thể tham khảo thêm tại Đặng Văn Đức, 2001,
trang 202-204).
Tương tự với kiểu raster, nhiều dạng thức tập tin khác nhau cũng được sử dụng cho
việc lưu trữ dữ liệu, đặc biệt là những dữ liệu bản đồ được số hóa từ các thiết bị chuyên
dụng hoặc từ các ảnh chụp viễn thám. Chẳng hạn, các dạng thức PCX (PC PaintBrush
Exchange), TIFF (Tagged Image File Format) thường được dùng cho các ảnh raster tạo
được từ máy quét hoặc các chương trình vẽ PC, dạng thức ADRG (Arc Digitized
Raster Graphics) được dùng bởi Quân đội US lưu các ảnh raster của bản đồ giấy, dạng
thức BIL (Band Interleaved by Line) và BIP (Band Interleaved by Pixel) được dùng
cho các hệ thống viễn thám.
Về việc liên kết dữ liệu không gian địa lý với dữ liệu thuộc tính (còn gọi là dữ liệu phi
không gian) trong hệ GIS cũng có nhiều mô hình khác nhau. Chẳng hạn, MapInfo lưu
dữ liệu không gian vào tập tin dạng .mif, dữ liệu thuộc tính vào tập tin dạng .mid, và cả
hai tập tin này đều thuộc về MapInfo. Kiểu lưu trữ này của MapInfo được xem là kiến
trúc tích hợp của hệ GIS (Đặng Văn Đức, 2001, trang 202). Còn ArcInfo lưu dữ liệu
không gian vào tập tin dạng .dhp, và dùng tập tin dang .dbf vay mượn từ cơ sở dữ liệu
quan hệ thương mại để lưu dữ liệu thuộc tính. Đây được xem là kiến trúc đối ngẫu của
hệ GIS (Đặng Văn Đức, 2001, trang 199). Ngoài ra, một mẫu kiến trúc tích hợp khác
Trang 13
của hệ GIS nữa là một số cơ sở dữ liệu quan hệ thương mại truyền thống nay được mở
Chương 1: OpenGis – Các khái niệm
rộng thêm để có thể hỗ trợ việc lưu trữ và xử lý dữ liệu không gian địa lý. Ví dụ cơ sở
dữ liệu Oracle nay có thêm phần Oracle Locator và Oracle Spatial.
Sự đa dạng về mô hình và cấu trúc dữ liệu dùng trong GIS một mặt cho thấy được sự
sáng tạo của con người nhằm đáp ứng nhu cầu sử dụng và phát triển các ứng dụng GIS,
nhưng mặt khác cũng kéo theo những khó khăn nhất định trong việc truyền thông, trao
đổi cũng như tích hợp dữ liệu GIS.
Để giải quyết vấn đề trao đổi dữ liệu GIS, một cách truyền thống người ta thường xây
dựng thêm các thành phần phần mềm làm nhiệm vụ chuyển đổi giữa các dạng thức dữ
liệu, thường được gọi là các bộ chuyển đổi (converter). Các bộ chuyển đổi này hoặc
được tích hợp trực tiếp vào các phần mềm GIS thương mại và thể hiện ở các chức năng
import/export, hoặc được cung cấp bởi một bên “thứ ba” trung gian nào đó.
Ngày này với sự phát triển của mạng máy tính nói chung và mạng Internet nói riêng,
các nhu cầu thừa kế, trao đổi, tích hợp và khai thác dữ liệu GIS từ nhiều nguồn khác
nhau giữa các tổ chức, cộng đồng và quốc gia trong môi trường mạng ngày càng gia
tăng và có ý nghĩa. Việc thi hành các tác vụ chuyển đổi dữ liệu theo kiểu truyền thống
không được xem là hiệu quả và thuận tiện cho lắm đối với người sử dụng. Người ta cần
tìm ra giải pháp mang tính hệ thống và chuẩn mực hơn nhằm đêm lại sự thuận lợi lâu
dài và bền vững cho những người khai thác GIS.
1.2 Khái Quát Về OpenGIS
1.2.1 Tổ chức OGC
Tổ chức Liên hiệp OpenGIS, gọi tắt là OGC (Open GIS Consortium), là một tổ chức
phi lợi nhuận và mang tính quốc tế, được thành lập vào nằm 1994 nhằm giải quyết các
vấn đề liên quan đến sự trao đổi chia sẽ các dữ liệu không gian địa lý và khả năng làm
việc phối hợp giữa các phần mềm GIS. Các hoạt động của OGC tạo ra những ảnh
Trang 14
hưởng có ý nghĩa đến cộng đồng GIS và việc thiết kế các hệ thống GIS trong tương lai.
Chương 1: OpenGis – Các khái niệm
Nhận xét về vấn đề dữ liệu đối với GIS, OGC cho rằng:
“Hiện trên Web và trong các kho lưu trữ độc lập có nhiều dữ liệu không gian địa lý,
nhưng chúng quá phức tạp, không đồng nhất và không tương thích nhau. Người dùng
cần phải có kiến thức chuyên môn và các phần mềm GIS chuyên biệt để bao phủ hoặc
kết hợp các lớp bản đồ khác nhau của cùng một vùng địa lý. Việc chuyển đổi dữ liệu
thường nặng nề và mất nhiều thời gian, nhưng kết quả lại không được như ý. Chỉ có
giao tiếp chung là cách cho phép sự bao phủ và kết hợp các loại thông tin địa lý phức
tạp khác nhau xảy ra một cách tự động trên Internet, bất chấp những khác biệt nằm
phía dước các hệ thống phần mềm GIS. OGC cung cấp cấu trúc hình thức để đạt được
sự thống nhất về các giao tiếp chung này.” (David Blasby)
Trên cơ sở nhận định này, mục tiêu bao trùm và dài hạn của OGC là:
“The full integration of geospatial data and geoprocessing resources into mainstream
computing and the widespread use of interoperable geoprocessing software and
geodata products throughtout the information infrastructure.” (Open GIS Consortium
Inc., 1999, Topic 0)
Tạm dịch:
“Tích hợp hoàn chỉnh các dữ liệu không gian địa lý và các cách xử lý thông tin địa lý
vào một luồng tính toán chính, và sử dụng phổ biến các sản phẩm dữ liệu địa lý và
phần mềm xử lý thông tin địa lý trong suốt cơ sở hạ tầng về thông tin.” (Open GIS
Consortium., 1999, Topic 0)
Theo ESRI (2003), việc tích hợp vào luồng tính toán chính mang ý nghĩa mở rộng
phạm vi trao đổi ứng dụng GIS ở mức tổ chức lớn hơn, chia sẽ dữ liệu không gian địa
lý không chỉ giữa các công nghệ GIS mà còn với các ứng dụng không phải GIS trên
những nền tảng khác nhau, và khả năng làm việc phối hợp giữa các chuẩn GIS với các
Trang 15
chuẩn IT công nghiệp.
Chương 1: OpenGis – Các khái niệm
Công việc của OGC là xây dựng và công bố các đặc tả mang tính mở cho các giao tiếp,
lược đồ và kiến trúc nhằm thúc đẩy khả năng tương thích giữa các kho dữ liệu không
gian địa lý, các ứng dụng và dịch vụ GIS không đồng nhất.
1.2.2 Định nghĩa OpenGIS
Các đặc tả mở được tạo bởi OGC được gọi là các đặc tả OpenGIS (Open GIS
Specifications). Vậy Open GIS là gì?
OpenGIS được định nghĩa là:
“Open and interoperable geoprocessing” or “The ability to share heterogeneous
geodata and geoprocessing resources transparently in a networked environment.”
(David, 2000)
Tạm dịch:
“Việc xử lý dữ liệu địa lý phải có tính mở và có khả năng làm việc liên thông” hoặc
“Khả năng chia sẻ một cách trong suốt các dữ liệu địa lý không đồng nhất và các tài
nguyên xử lý về mặt địa lý trong môi trường mạng.” (Dương Anh Đức)
Hai khái niệm “mở” (open) và “khả năng làm việc liên thông” (interoperability) là hai
khái niệm trung tâmcủa OpenGIS.
Mở được hiểu là nhiều thành phần tham gia soạn thảo các đặc tả, và các kết •
quả đặc tả được tự do tham khảo và sử dụng.
• Khả năng làm việc liên thông là khả năng tương thích của các ứng dụng nhằm
khắc phục những trở ngại do sự không dồng nhất các môi trường xử lý cũng
như sự không đồng nhất về dữ liệu.
Tóm lại, có thể nói rằng các đặc tả OpenGIS được xây dựng nhằm giúp cho việc truy
cập các dữ liệu không gian địa lý và các dịch vụ xử lý dữ liệu trở nên trong suốt trong
Trang 16
môi trường làm việc mạng.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Chương 2 : Hệ Thống Hỗ trợ Phân tích Tài nguyên Địa lý
Chương 2 giới thiệu về phần mềm GRASS (The Geogaphic ResourcesAnalysis
Support System), là một hệ thống hỗ trợ phân tích tài nguyên địa lý. Đề cập một cách
khái quát về khía cạnh sử dụng cũng như trong lãnh vực lập trình .
2.1 Sơ lược về GRASS Là một hệ thống thông tin địa lý (GIS – Geographic information system), phát triển
theo chuẩn của OpenGIS, nguyên gốc được thiết kế và phát triển bởi những nhà nghiên
cứu tại Phòng Thí nghiệm Xây dựng của quân đội Mỹ (US Army Construction
Engineering Research Laboratory - USACERL) và ngày nay, nó được hỗ trợ bởi nhóm
phát triển GRASS có tổng hành dinh tại ITC-irst, Trento Italy) và Đại học Baylor,
Waco (Mỹ).
GRASS là một phần mềm mã nguồn mở (GNU – General Public Licence), được phát
hành lần đầu năm 1985. Phát triển trong hơn 20 năm qua, kích thước GRASS vào
khoảng 100 MB và là một bộ thư viện lớn để phục vụ việc xây dựng các ứng dụng
GIS. GRASS được viết bằng ngôn ngữ C (khoảng 1,5 triệu dòng mã lệnh) và có thể
được biên dịch trên các hệ điều hành phát triển trên nền Unix như SUN Solaris,
SunOS, HP, SCO, Linux, DEC Alpha v.v.. và có thể chạy trên Windows thông qua môi
trường giả lập Cygwin (chương trình giả lập LINUX/UNIX trên nền Windows)
GRASS có khả năng lưu trữ, phân tích và hiển thị một cách sinh động dữ liệu không
gian đã được số hoá. Hiện tại, phiên bản GRASS đã ra đến 5.x và là một trong mười
phần mềm mã nguồn mở có qui mô lớn nhất hiện nay . Đã có nhiều tổ chức, chính phủ,
trường học và công ty sử dụng thư viện GRASS để phát triển những ứng dụng chuyên
Trang 17
biệt cho riêng mình.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Những đối tượng GRASS hướng đến là các nhà qui hoạch, sinh thái học, địa chất học,
địa lý học và những kỹ sư trắc địa vẽ bản đồ, tuy nhiên người sẽ trực tiếp sử dụng
GRASS lại là các lập trình viên. Hầu hết các đối tượng GRASS hướng đến đều có
trình độ tin học hạn chế, họ tự mình không thể xây dựng một chương trình tin học phức
tạp liên quan đến GIS để phục vụ công việc của bản thân, tuy rằng công việc chuyên
môn rất cần sự hỗ trợ của những phần mềm tin học như vậy. GRASS cung cấp một bộ
hàm), và bản thân GRASS cũng dựa trên bộ thư viện này để phát triển một số chức
thư viện để xây dựng ứng dụng GIS tương đối đầy đủ gọi là GISLIB (khoảng trên 800
năng cơ bản về GIS. Việc xây dựng một hệ GIS thật sự rất phức tạp nếu bắt tay từ đầu,
và vì thế, nhờ sự hỗ trợ của bộ thư viện này lập trình viên sẽ có thể nhanh chóng xây
dựng được các ứng dụng GIS hỗ trợ cho các đối tượng người dùng trên một cách dễ
dàng và nhanh chóng.
GRASS được thiết kế và phát triển cho nhiều mức độ sử dụng khác nhau, ở thời điểm
hiện tại có thể phân chia như sau :
• Mức chuyên biệt hoá : cho những người dùng mới học cách sử dụng, trình
độ tin học không cao. GRASS hiện tại hỗ trợ giao tiếp người dùng thông
qua giao diện đồ họa được viết bằng script TCL/TK. Cho phép xây dựng
nên các command truy vấn thông qua menu, dialog. Giao diện này thực chất
là lớp vỏ bọc cho những command chuyên biệt bên dưới.
• Mức command, gõ lệnh trực tiếp : đây là mức thông dụng nhất và được sử
dụng nhiều nhất. Trên môi trường LINUX/UNIX việc gõ command sẽ giúp
thao tác nhanh với hệ điều hành rất nhiều so với giao tiếp giao diện đồ họa.
GRASS ở mức giao tiếp này hỗ trợ người dùng gõ command trực tiếp để
truy vấn và sử dụng.
• Mức lập trình : đây là những developer, có trình độ tin học cao. Sử dụng
Trang 18
những bộ thư viện được cung cấp sẵn của GRASS để phát triển nên những
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
ứng dụng cho bản thân. Ràng buộc là các developer phải sử dụng những
hàm đã được hỗ trợ (nếu có) để mở rộng và phát triển, không viết lại những
gì đã có để tránh trùng lắp và bug
• Mức xây dựng thư viện : đây là công việc của nhóm phát triển GRASS đang
làm. Họ có trách nhiệm duy trì sự ổn định, phát hiện sửa chữa những lỗi và
đảm bảo một nền tảng thư viện hàm tốt để các ứng dụng được phát triển và
mở rộng trên đó.
GRASS hỗ trợ các chức năng chính yếu :
• Phân tích dữ liệu Raster (Raster Analysis)
• Phân tích dữ liệu Vector (Vector Analysis)
• Phân tích dữ liệu Điểm (Point Analysis)
• Xử lý hình ảnh (Image Process)
• Phân tích DTM ( DTM – Analysis)
• Hiển thị thông tin (Screen Displaying)
• Tạo lập bảng đồ (map creation)
• Hỗ trợ SQL ( PostgreSQL, MySQL ..)
• Các module khác (được các nhóm khác xây dựng và gắn vào)
2.2 Kiến trúc GRASS Ở mức độ tổng quan, có thể mô tả kiến trúc của bộ thư viện GRASS như hình vẽ sau :
Trang 19
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
GRASS GIS LIB
Lôùp 0
Lôùp 1
Döõ lieäu RASTER
Döõ lieäu VECTOR
Döõ lieäu POINT
Lôùp 2
Xöû lyù hình aûnh
Phaân tích DTM
Quaûn lyù cô sôû döõ lieäu
Nhöõng module khaùc
Hình 2 - 1 Mô hình kiến trúc GRASS
GRASS được viết theo bằng C nên hoàn toàn không có yếu tố hướng đối tượng trong
kiến trúc. Các chức năng được đóng lại thành các gói. Theo chiều mũi tên, các gói
được phân thành kiến trúc lớp như trên, những gói thuộc lớp cao sẽ sử dụng các chức
năng do các gói ở lớp thấp cung cấp.
Những module khác có thể là các hỗ trợ phụ thêm cho GRASS như giao tiếp ODBC
với hệ quản trị cơ sở dữ liệu Postgres, cung cấp nơi lưu trữ, truy vấn cho cơ sở dữ liệu
không gian...
2.3 Định dạng dữ liệu GRASS lưu trữ dữ liệu theo một tổ chức thư mục được phân cấp được qui ước và mỗi
loại dữ liệu có định dạng lưu trữ xác định. Dữ liệu vector (vector data) được lưu theo
định dạng nhị phân, dữ liệu điểm (site / point data) được lưu theo định dạng ASCII và
dữ liệu ảnh (raster/imagery data) được lưu theo định dạng nhị phân và được nén. Về
phương diện lập trình GRASS được cung cấp thư viện GIS Library dùng để giao tiếp
với cơ sở dữ liệu của GRASS. Thư viện GIS Library cung cấp đủ các hàm khiến cho
Trang 20
lập trình viên có thể không cần phải hiểu cấu trúc của CSDL lưu bên dưới. Thư viện
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
GRASS dùng các biến môi trường (environment variable) để thiết lập các thông số cho
các hàm thư viện GIS Library truy xuất.
GRASS hỗ trợ 3 định dạng dữ liệu :
(cid:153) Dữ liệu Raster : là kiểu dữ liệu dạng pixel, có thể là các ảnh TIFF, GIF, PPM, ảnh
chụp vệ tinh …
Hỗ trợ import các định dạng :
(X Y Z , Z trong khoảng -2E7 đến 2 E7) 1. ASCII
2. TIFF (8 bit)
3. GIF (8 bit)
4. PPM (24 bit)
5. SUN Raster (8 bit)
6. NHAP ( ảnh không gian)
7. BIL/BSQ (ảnh vệ tinh)
8. LANDSAT TM, MSS (ảnh vệ tinh)
9. SPOT (ảnh vệ tinh)
Hỗ trợ kết xuất từ Raster ra các định dạng như :
1. ASCII (X Y Z , Z trong khoảng -2E7 đến 2 E7)
2. PPM (24 bit)
3. PPM/3 (24 bit)
4. TGA (24 bit)
Trang 21
5. TIFF (8 bit)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
(cid:153) Dữ liệu Vector : dữ liệu thể hiện hình dạng vật lý bên ngoài của đối tượng như :
dòng sông, đường xá, hồ nước hoặc cánh đồng … Được định dạng theo kiểu vector.
Hỗ trợ import các định dạng như :
1. ASCII vectorformat
2. ARC/INFO (các file có phần mở rộng .arc, .line, .point và .textlabel )
3. DXF
4. DXF3D
5. DLG
6. IDRISI
7. TIGER
Hỗ trợ kết xuất từ dữ liệu vector ra các định dạng
1. ASCII vectorformat
2. ARC/INFO
3. DXF
4. IDRISI
5. MOSS
(cid:153) Dữ liệu điểm (Point data): trong GRASS được gọi là “sites”. Dữ liệu điểm có thể là
độ cao, lượng mưa ở một toạ độ xác định. Gọi là điểm vì thông tin thể hiện cho một toạ
độ xác định trên bản đồ
Trang 22
Định dạng hỗ trợ import và kết xuất là : ASCII format
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
2.4 Tổ chức lưu trữ dữ liệu của GRASS
2.4.1 GISDBASE :
Cơ sở dữ liệu trong GRASS sử dụng kiến trúc thư mục kiểu UNIX. Mức cao nhất được
gọi là GISDBASE, người dùng phải cung cấp thông tin này khi đăng nhập sử dụng
GRASS và thông tin sẽ được chứa trong biến môi trường GISDBASE. Truy xuất lại
thông tin này, ta dùng hàm G_gisdbase
2.4.2 LOCATION :
Thư mục con của GISDBASE là Location, có thể xem Location là những cơ sở dữ liệu
độc lập nhau của các vùng khác nhau và GISDBASE là tập các cơ sở dữ liệu mà
GRASS hiện đang được dùng để quản lý.
Người dùng phải xác lập Location sẽ làm việc khi đăng nhập sử dụng GRASS, thông
tin này sau đó sẽ được chứa trong biến môi trường LOCATION_NAME, và được trả
về khi sử dụng hàm G_location để truy vấn.
Trong một phiên làm việc, GRASS chỉ có thể làm việc với một Location duy nhất
GISDBASE
LOCATION .4
LOCATION .1
LOCATION .2
LOCATION .1
trong số những Location mà GISDBASE quản lý.
Hình 2 - 2 Minh họa cấu trúc lưu trữ của GISDBASE trên đĩa
Trang 23
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
2.4.3 MAPSETS
Thư mục con của Location là mapset (tập bản đồ). Người dùng phải đăng ký mapset sẽ
sử dụng trong Location cho GRASS khi đăng nhập. Mapset được chọn sẽ đựơc lưu
trong biến môi trường MAPSET và giá trị biến môi trường này được truy xuất thông
LOCATION
PERMANENT
….
MAPSET .2
MAPSET .1
qua G_mapset
Hình 2 - 3 Minh họa cấu trúc lưu trữ của LOCATION trên đĩa
Người dùng chỉ được sửa đổi đối với những mapset được tạo ra bởi chính người dùng.
Đối với những mapset khác, người dùng chỉ có thể xem nhưng không được thực hiện
việc sửa đổi (tuy nhiên, nếu chủ nhân của mapset không cho xem, bằng cách đặt quyền
sử dụng file thông qua Unix File System, thì ta cũng không xem được các mapset này).
Vậy đường dẫn đến một Mapset là : GISDBASE/LOCATION/MAPSET. Thông tin
này có thể lấy ra thông qua hàm G_location_path
Cấu trúc Mapset bao gồm : các file và các thư mục con khác (được gọi là các element,
Trang 24
trong sơ đồ các element được vẽ với dấu /).
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
MAPSET
SEARCH_PATH
WIND
cats/
cell/
paints/
….
Hình 2 - 4 Minh họa cấu trúc lưu trữ của MAPSET trên đĩa
Các file trong mapset
• GROUP : nhóm hình ảnh hiện tại (current imagery group), được dùng bởi
các hàm xử lý hình ảnh (imagery function).
• SEARCH_PATH : đường dẫn tìm kiếm của Mapset (mapset search path),
đựơc tạo và sửa đổi bởi lệnh g.mapsets. Nó chứa bên trong danh sách các
mapset có thể được sử dụng để tìm kiếm các file cơ sở dữ liệu. Khi người
dùng gõ vào tên một một file cơ sở dữ liệu mà không ghi rõ thuộc mapset
nào, thông tin đó sẽ được tìm kiếm trong file SEARCH_PATH này.
: khu vực hiện tại (current region), file được tạo và sửa đổi bởi • WIND
lệnh g.region, nội dung của WIND được lấy ra bởi lệnh G_get_window.
• Các ELEMENTS : Các element này không được tạo khi mapset được tạo
mà các command của GRASS sẽ tạo động khi nó tham chiếu đến (ví dụ :
g.ask). Vì các element không chắc chắn đã tồn tại, nên ta phải luôn kiểm tra
Trang 25
sự hiện diện của nó trước khi thực hiện các thao tác.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Các elements Chức năng
cell file nhị phân raster (số nguyên – INT)
fcell file nhị phân raster (số thực –
FLOAT/DOUBLE)
cellhd file header cho các raster map
cats Thông tin được phân loại của các raster
map (category raster map information)
colr Bảng màu của raster map
colr2 Bảng màu thứ hai của raster map
cell_misc Những file linh tinh khác phục vụ cho
raster map
hist File lưu các thông tin “lịch sử” của
raster map
dig Dữ liệu nhị phân vector (binary vector
data)
dig_ascii Dữ liệu dưới dạng ascii của vector (ascii
vector data)
dig_att các thuộc tính vector được hỗ trợ
Trang 26
(vector attribute support)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
dig_cats danh mục các label của vector được hỗ
trợ (vector category label support)
dig_plus đồ hình vector được hỗ trợ (vector
topology support)
reg các đăng ký (registration)
arc các file ARC/INFO là những file không
được tạo tự động. Dùng cho việc trao
đổi dữ liệu (data-exchange)
bdlg File nhị phân dlg, dùng cho việc trao
đổi dữ liệu
dlg file ascii dlg, dùng cho việc trao đổi dữ
liệu
dxf file ascii DXF, dùng cho việc trao đổi
dữ liệu
camera dùng bởi hàm i.ortho.photo, là file đặc
tả camera
icons những file biểu tượng, được dùng bởi
hàm p.map
group dữ liệu hỗ trợ cho các nhóm hàm xử lý
Trang 27
hình ảnh
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
site_lists danh sách các site của module liên quan
Windows vùng được định nghĩa trước (predefine
region)
COMBINE dùng trong script r.combine
WEIGHT dùng trong script r.weight
Mỗi location đều có những dữ liệu mapset thuộc loại cố định (PERMANENT
MAPSET). Mapset này chứa các file dữ liệu raster và vector nguyên gốc không được
phép sửa đổi và các file đặc biệt khác.
• MYNAME : mô tả thông tin về location. Có thể truy xuất thông qua hàm
G_myname
• DEFAULT_WIND : mô tả region mặc định cho location, được trả về thông
qua hàm G_get_default_window. File này được dùng để khởi tạo WIND file
khi GRASS tạo mới một mapset trong Location.
• PROJ_INFO : chứa các thông tin về project
• PROJ_UNITS : chứa thông tin về các unit của project
Ràng buộc khi sử dụng cơ sở dữ liệu mapset
Dựa trên ba ràng buộc cơ bản :
1. Người sử dụng chỉ được chọn mapset đó để làm việc nếu đó là chủ nhân của
mapset đó
Trang 28
2. GRASS chỉ tạo và sử đổi file chỉ trên mapset hiện tại được chọn
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
3. Tất cả các file trong các mapset đều có thể được đọc bởi những người sử dụng
không phải chủ nhân của nó (thông qua MAPSET SEARCH_PATH để truy
xuất), nếu chủ nhân của các mapset này “chia sẻ” , cho phép các user khác được
xem (thông qua cơ chế UNIX file permission)
2.4.4 REGION và MASK
GRASS cung cấp hai cơ chế cho phép người dùng lựa chọn khu vực sẽ quan sát và
phân tích dữ liệu của họ, được gọi là lựa chọn theo kiểu “khu vực” (region) và lựa chọn
theo kiểu “mặt nạ” (mask). Người sử dụng định nghĩa một khu vực hình chữ nhật để
tạo ra một “lựa chọn theo kiểu khu vực” (region) và sau đó có thể tuỳ ý giới hạn lại bớt
khu vực được chọn đó bằng một “mặt nạ” (mask). Dữ liệu về region và mask sẽ được
tự động lưu trữ vào cơ sở dữ liệu GRASS trong MAPSET hiện tại được người sử dụng
chọn lựa.
Các module của GRASS tự động làm việc với những dữ liệu nằm trong region đã được
chọn, nếu có thêm mask thì chỉ những dữ liệu trong region sau khi vượt được qua lớp
“mặt nạ“ sẽ được chọn để xử lý.
(cid:132) REGION
Để chọn khu vực làm việc, người sử dụng thao tác qua lệnh g.region, hoặc d.zoom, và
những thông tin này sau đó được lưu trong file WIND của MAPSET. File này không
chỉ xác lập sự giới hạn của khu vực địa lý được chọn trong một khuôn viên hình chữ
nhật mà dựa trên độ phân giải của khu vực đó, một cách ngầm định GRASS sẽ phân
khu vực thành những cell hình chữ nhật có cùng kích thước.
File WIND chứa những thông tin sau :
north: 4660000.00
south: 4570000.00
Trang 29
east : 770000.00
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
west : 710000.00
e-w resol: 50.00
n-s resol: 100.00
rows: 900
cols: 1200
proj: 1
zone: 18
north, south, east, west : tọa độ bốn góc định ra khu vực làm việc
rows, cols : số lượng dòng và cột được chia ra trong khu vực làm việc
e-w resol, n-s resol : Độ phân giải theo chiều rộng và chiều dài của khu vực làm việc.
Đây chính là kích thước của mỗi cell được chia nhỏ ra từ khu vực làm việc ban đầu. e-
w resol là chiều dài của cell và n-s resol là chiều rộng của cell.
proj, zone :
proj giúp xác định loại toạ độ được sử dụng :
0 : không sử dụng tọa độ (x,y), loại bản đồ image
1 : UTM
2 : State Plane
3 : Kinh độ, vĩ độ (Latitude Longitude)
Trang 30
zone xác định trường của proj, trong ví dụ trên là zone 18
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
(cid:132) MASK
Bên cạnh việc chọn khu vực làm việc (region), người sử dụng có thể dùng lệnh r.mask
để tạo mặt nạ. Mặt nạ này sẽ được lưu thành file MASK trong thư mục MAPSET hiện
tại của người dùng.
INPUT
MASK
OUTPUT
3 4 4
0 4 4
0 1 1
3 3 4
3 3 0
1 1 0
+
=
2 3 3
2 0 0
1 0 0
Mặt nạ hoạt động như một bộ lọc khi đọc dữ liệu từ file raster.
Hình 2 - 5 Minh họa cơ chế MASK của GRASS
GRASS 5 Không hỗ trợ mặt nạ dấu chấm động..
2.4.5 Các biến môi trường sử dụng trong GRASS
Các module của GRASS được viết độc lập với cơ sở dữ liệu được sử dụng bởi người
dùng, cơ sở dữ liệu đó được lưu ở đâu, cũng như vị trí các module làm việc của
GRASS .. Các thông tin này cũng rất cần cho quá trình xử lý, GRASS sẽ tạo các biến
môi trường để ghi nhận và lấy ra khi cần thiết.
Khi được khởi động bằng lệnh grass5.0, GRASS lập tức khởi tạo thông tin cho các
biến môi trường sau
• GISBASE : là đường dẫn tuyệt đối đến thư mục chứa cài đặt của GRASS.
• GIS_LOCK : biến này ghi nhận đường dẫn đến file gis_lock, là file
GRASS dùng để đảm bảo cơ chế lock (khoá) của chương trình.
• GISRC : chỉ đến thư mục lưu trữ file .grassrc5, là file chứa thông tin về tất
cả các biến môi trường. Khi được khởi động, GRASS sẽ đọc từ file
Trang 31
.grassrc5 để khởi tạo các biến môi trường khác được lưu trong đó.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
• GISDBASE: biến này ghi nhận đường dẫn đến thư mục cài đặt cơ sở dữ
liệu của GRASS, thông tin biến này được đọc lên từ file .grassrc5 và được
GRASS khởi tạo thành biến môi trường
• LOCATION_NAME: biến này ghi nhận đường dẫn đến thư mục
LOCATION sẽ làm việc, thông tin biến này được đọc lên từ file .grassrc5
và được GRASS khởi tạo thành biến môi trường.
• MAPSET : biến này ghi nhận đường dẫn đến thư mục MAPSET sẽ làm
việc, thông tin biến này được đọc lên từ file .grassrc5 và được GRASS khởi
tạo thành biến môi trường.
• MONITOR : Monitor đang được chọn để hiện thi hiện tại
• PAINTER : thiết bị hiện thị đang được chọn
• DIGITIZER : digitizer đang được chọn
Các biến môi trường được lưu trong .grassrc5 được gọi là biến môi trường GRASS và
được thao tác thông qua hai hàm thư viện : G_getenv và G_setenv. Hai hàm này đảm
bảo các thông tin biến môi trường GRASS được lưu xuống file khi có sự thay đổi.
2.5 Dữ liệu RASTER
2.5.1 Ý niệm sơ lược
Dữ liệu dạng này có thể xem là được kết hợp lại từ một ma trận các ô. Nó có thể là một
bản đồ giấy, một ảnh vệ tinh, hoặc một bản đồ có được do tổng hợp từ nhiều bản đồ
khác.
Bản đồ được phân rã thành ma trận, gồm nhiều ô, mỗi ô được gọi là một grid cell. Ô
grid cell là đơn vị nguyên tố của bản đồ, thể hiện một dữ liệu đã được qui ước và đánh
số thành danh mục.
Trang 32
Ví dụ : Raster map sau
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
2
3
3
3
4
4
2
2
3
3
4
4
2
2
3
3
4
4
3
3
1
1
3
4
3
1
1
1
3
4
3
3
1
1
4
4
Raster map về sự phân bố đất đai
Với danh mục được qui định là
1 : Thành thị
2 : Đồng cỏ
3 : Rừng
4 : Đầm lầy
Mỗi ô, bên cạnh dữ liệu thể hiện tọa độ, còn đi kèm theo dữ liệu thể hiện ý nghĩa của
cell (trong bản đồ ví dụ bên trên là các giá trị 1, 2, 3, 4). Người dùng có thể gán màu
sắc tương ứng cho từng lọai giá trị cell tùy thích (trong ví dụ trên màu đen cho giá trị
1). Từ đó sẽ có hai khả năng xảy, hoặc là ta giữ nguyên màu sắc nguyên thủy của ô từ
bản đồ gốc được đưa vào để hiện thị, hoặc là ta gán giá trị màu thể hiện cho từng giá trị
ô (điều này có thể làm thay đổi hình ảnh được hiện thị lên của bản đồ so với bản đồ gốc
Trang 33
được nhập vào).
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
2.5.2 Hệ thống tập tin raster
Để phục vụ cho một bản đồ raster map, thông tin được phân rã và lưu trên nhiều file.
Các file này có tên giống nhau nhưng được chứa trong những thư mục khác nhau trong
thư mục mapset ( tên thư mục sẽ thể hiện nội dung thông tin phân rã của file đó).
Thư mục Thông tin
cell File nhị phân thể hiện thông tin của các raster cell ( được thể
hiện bằng số nguyên int)
fcell File nhị phân thể hiện thông tin của các raster cell ( được thể
hiện bằng số thực float/double)
cellhd các file header của raster
Danh mục (category information) của các raster map cats
colr bảng màu của raster map
colr2 bảng màu thay thế của raster map
hist File lưu vết, lịch sử của raster map
cell_mísc Những thông tin khác (linh tinh, không thật sự quan trọng)
Ví dụ : raster map về đất đai (soils), có thể có các file sau : cell/soils, cellhd/soils,
colr/soils, và cats/soils.
Những thư mục phân rã này được gọi là các “thành phần dữ liệu” (database elements).
2.5.3 Các thao tác quan trọng
(cid:153) Nhận dữ liệu từ một tập tin bên ngoài (import data)
Trang 34
Tùy theo lọai dữ liệu, ta dùng các lệnh sau
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Dữ liệu là file ảnh định dạng ppm
$d.in.ppm
Dữ liệu là file ảnh định dạng ASCII
$d.in.ascii
(cid:153) Kết xuất dữ liệu (export data)
Tùy theo lọai dữ liệu muốn kết xuất, ta dùng các lệnh sau
Dữ liệu kết xuất là file ảnh định dạng ppm
$d.out.ppm
Dữ liệu kết xuất là file ảnh định dạng ppm
$d.out.ascii > textfile.asc
(cid:153) Hiện thị dữ liệu raster
d.rast
2.6 Dữ liệu VECTOR (VECTOR DATA)
2.6.1 Ý niệm sơ lược
Dữ liệu vector được sử dụng đối với những đối tượng có kiến trúc và hình thể, nghĩa là
trong thực tế các đối tượng này có hình dạng và kích thước xác định. GRASS sử dụng
dữ liệu vector để “mã hoá” đường biên bao bọc hình dạng của kiến trúc hoặc vật thể
cần thể hiện.
Ví dụ : những đối tượng mà dữ liệu vector có thể dùng để “mã hoá” là hệ thống
đường xá, cầu cống, núi non, hồ nước, cánh đồng, sơ đồ qui hoạch thành phố ...
Nói chung, những đối tượng dạng này có đặc điểm là hình dạng của chúng có
Trang 35
thể dùng những đường liền nét để thể hiện.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
2.6.2 Hệ thống tập tin vector
Bản đồ Vector trong GRASS được lưu trữ thành các cung. Cung được tạo thành từ một
loạt toạ độ (x, y). Hai điểm đầu cuối của một cung được gọi là nốt ( node). Hai cặp
(x,y) kề nhau trong cung được gọi là một phân đoạn (segment) của cung.
(cid:153) Những cung có thể biệt lập hoặc kết hợp với nhau tạo nên những hình thể trên
bản đồ : đường thẳng ( sông ngòi, đường xá ...) , các khu vực ..
(cid:153) Các cung tạo nên những đường liền nét (sông ngòi, đường xá .. ) được gọi là các
“đường liền” (lines)
(cid:153) Các cung phân ranh nên một vùng, khu vực được gọi là các “đường ranh bao
bọc” (area lines).
Mỗi loại thông tin hiện thị trên bản đồ vector được gán với một con số nguyên gọi là số
chỉ mục tương tự kỹ thuật dùng cho raster map layer (category number).
Thông tin của một bản đồ vector trong GRASS được chứa trong nhiều file dữ liệu.
Tương tự như raster map layer, các file này có tên trùng nhau nhưng được chứa trong
các thư mục con khác nhau trong thư mục mapset, mỗi file này biểu thị cho một thông
tin đã được phân rã.
Thư mục Chức năng
dig file nhị phân, chứa thông tin cung
dig_ascii file ascii, chứa thông tin cung
dig_att file phân loại các thuộc tính ( category
attribute file)
Trang 36
dig_cats Tên các danh mục phân loại của vector
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
(vector category labels)
dig_plus File chỉ mục của dữ liệu vector
vector pointer/ index file
reg digitizer registration points : những
điểm đã được đăng ký
Ví dụ: bản đồ vector về đất đai (soils) có thể được lưu trữ theo cấu trúc sau : dig/soils,
dig_plus/soils, dig_ascii/soils, dig_cats/soils và reg/soils ..
Vector file còn được gọi là file số hoá (digit file), vì nó được tạo và thao tác bởi thư
viện các hàm digit : v.digit ..
2.6.3 Các thao tác quan trọng
(cid:153) Nhận dữ liệu từ một tập tin bên ngoài (import data)
Dùng lệnh
$v.in.arc
(cid:153) Kết xuất dữ liệu (export data)
(cid:145) Theo định dạng ARC/INFO
Dùng lệnh
$v.out.arc
và trả lời các tham số cho lệnh
(cid:145) Theo định dạng DFX
Trang 37
Dùng lệnh
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
$v.out.dfx
và trả lời các tham số cho lệnh
(cid:153) Hiện thị dữ liệu vector
Dùng lệnh
$d.vect
và trả lời các tham số cho lệnh
(cid:153) Kết xuất sang các định dạng dữ liệu khác của GRASS
Ta dùng lệnh sau để kết xuất sang dữ liệu định dạng vector
$v.to.vect
Ta dùng lệnh sau để kết xuất sang dữ liệu định dạng vector
$v.to.rast
2.7 Dữ liệu điểm (POINT/SITE DATA)
2.7.1 Ý niệm sơ lược
Trong nghiên cứu về môi trường, có những loại dữ liệu chỉ liên quan đến một vị
trí hay một khu vực rất nhỏ : số liệu về lượng mưa ghi nhận được một trạm quan
sát, số liệu về độ cao đo được tại một điểm ... Khi biểu hiện lên trên bản đồ,
người ta dùng một chấm để thể hiện, kèm theo đó là màu sắc và các số liệu.
Những dữ liệu dạng này được gọi là dữ liệu điểm (point data) và GRASS có
thêm một tên gọi khác là dữ liệu nơi chốn (site data). Loại dữ liệu này có thể
hiểu một cách nôm na là dữ liệu “không có hình thể”, tức là trong thực tế nó
Trang 38
không có hình dạng cụ thể và ta qui ước dùng một điểm để biểu diễn nó.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Hình 2 - 6 Minh họa dữ liệu điểm – POINT/SITE
2.7.2 Hệ thống tập tin site
Dữ liệu điểm được lưu trong các tập tin định dạng ASCII, gọi là các tập tin site
hoặc tập tin danh sách (list file). Những tập tin này được xử lý bởi các mô-đun
xử lý dữ liệu nơi chốn (module sites) trong thư viện GRASS.
Trường name : Dòng này chứa tên của file site, và được in trên tất cả các báo
cáo được tạo bởi module s.menu. Chữ name phải được viết thường. Dòng thông
tin name này có thể được để trống vì s.menu sẽ tự động thêm tên mặc định là tên
của file site.
Trường desc : Dòng này chứa mô tả về file site, chữ desc buộc phải viết
thường. Dòng thông tin này sẽ được in trên tất cả các báo cáo được tạo bởi
module s.menu. Nó có thể được bỏ qua, trong trường hợp này, file site sẽ không
có mô tả
Các trường point : Những dòng còn lại là những record point. Mỗi site được
mô tả bởi một record point và cấu trúc của một record như sau
east|north[|dim]...|#cat %double [%double] @string [@string]
hoặc mô tả về ngày giờ như sau :
Trang 39
east|north[|dim]...|time %double [%double]
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Ví dụ :
name | sample
desc | sample site list
728220 | 5182440 | #27 %1.34 %23.13 @"pH 7.1"
727060 | 5181710 | #28 %2.32 %22.21 @"pH 6.8"
725500 | 5184000 | #29 %4.73 %17.34 @"pH 5.5"
719800 | 5187200 | #30 %3.65 %27.79 @"pH 6.2"
2.7.3 Các thao tác quan trọng
(cid:153) Nhận dữ liệu từ một tập tin bên ngoài (import data)
Ta dùng lệnh sau :
$s.in.ascii
File dữ liệu file theo định dạng UNIX ASCII ( nghĩa là ký tự phân cách dòng
sẽ là \r thay vì \r\n như trong DOS ASCII). Nếu sử dụng file DOS ASCII, ta
có thể dùng lệnh của UNIX để convert lại như sau :
$dos2unix file.asc
(cid:153) Kết xuất dữ liệu ra tập tin dạng text ASCII
Ta dùng lệnh
$s.out.ascii > file.asc
Trong lệnh trên, có một chỉ thị rất LINUX/UNIX đó là “>” dùng để chuyển
nội dung vào một file.
(cid:153) Hiện thị dữ liệu điểm
Trang 40
Ta dùng lệnh
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
$d.sites
(cid:153) Kết xuất sang các định dạng dữ liệu khác của GRASS
Ta dùng lệnh sau để kết xuất sang dữ liệu định dạng vector
$s.to.vect
Ta dùng lệnh sau để kết xuất sang dữ liệu định dạng raster
$s.to.rast
2.8 Các thư viện được cung cấp bởi GRASS (src/libes)
2.8.1 Danh sách
Tên thư viện Ý nghĩa
D Thư viện hiển thị
bitmap Thư viện xử ly bitmap cho X Windows
Bitmap
btree Xử lý b-cây
bwidget Thư viện tcl/tk mở rộng
coorcnv Thư viện hỗ trợ chuyển đổi toạ độ và dữ
liệu
datetime Thư viện xử lý ngày giờ
dbmi Giao diện làm việc với các driver của
Trang 41
các hệ quản trị cơ sở dữ liệu
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
dig_atts Thư viện để đọc và ghi từ các file thuộc
tính của bản đồ (attribute files)
digitizer Thư viện “thô”, đơn giản nhất cung cấp
xử lý chung cho digitizer
Thư viện hiện thị của driver CELL display
Thư viện xử lý cho các file DLG dlg
Thư viện các file hiện thị G3D dspf
Tính toán hình học (geometrical geom
calculations), tính toán cho các phép
toán số nguyên lớn (long –interger), ..
Thư vịên GIS chính yếu của GRASS gis
Các chức năng xử lý tính toán chung gmath
(ma trận, fft ..)
B Cây cho xử lý số nguyên (phát triển ibtree
từ thư viện btree)
Thư viện xử lý các biểu tượng (icon). icon
Thư viện xử lý hình ảnh imagery
Mở rộng của thư viện imagery image3
Trang 42
Thư viện xử lý hình ảnh , hỗ trợ save libimage
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
ảnh ở dạng SGIs RGB.
Thư viện hỗ trợ xây dựng, quản lý danh linkm
sách liên kết (linked-list)
Cơ chế khoá của GRASS đối với các lock
monitor dùng hiện thị và các file
Được chuyển từ thư viện gsurf, cần cho ogsf
NVIZ
Thư viện quản lý project proj
Thư viện hỗ trợ xử lý dữ liệu raster của raster
GRASS
row in/out library rowio
Thư vịên segment segment
Thư viện quản lý curses vask
Thư viện làm việc với dữ liệu vector vect32
Thư viện làm việc với dữ liệu vector vect32_64
32/64 bit của GRASS, được phát triển
trên nền vect32
2.8.2 Giới thiệu sơ bộ hàm và thư viện
Trang 43
(cid:153) Thư viện GIS ( thư viện trung tâm của GRASS)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
GIS Library là thư viện chính yếu và quan trọng nhất của hệ thống GRASS. Các
chương trình sử dụng GRASS để phát triển buộc phải sử dụng thư viện này để giao tiếp
với các file CSDL.
Các hàm được cung cấp trong thư viện này theo nhóm, không theo thứ tự alphabet. Các
hàm này có tiền tố bắt đầu là G_ (chữ G viết tắt cho Global)
Để sử dụng thư viện này trong lập trình, ta phải
#include
(cid:145) Khởi tạo: ta bắt buộc phải thực hiện thao tác khởi tạo trước khi có thể sử dụng bất
cứ hàm nào của thư viện GIS, bằng cách gọi hàm
int G_gisinit (char *program_name)
Ví dụ :
int main (int argc, char **argv)
{
G_gisinit(argv[0]);
}
(cid:145) Cơ chế báo lỗi của thư viện
Chức năng Hàm
int
G_fatal_error (char *message, ...) In thông điệp báo lỗi lên màn hình và
thóat.
Trang 44
Nếu có file GIS_ERROR_LOG trong
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
GISBASE, lỗi sẽ được ghi nhận lại
trong file
int In thông điệp lỗi lên màn hình và tiếp
tục G_warning (char *message, ...)
Nếu có file GIS_ERROR_LOG trong
GISBASE, lỗi sẽ được ghi nhận lại
trong file
void Thay đổi cơ chế xử lý lỗi của thư viện
(nếu không muốn xử lý lỗi thông qua G_set_error_routine (int (*handler)(
hai hàm trên) ))
Người lập trình cung cấp một cơ chế xử
lý lỗi thông qua một hàm có prototype :
int handler (char *message, int fatal)
fatal có giá 1 (error) và 0 (Warning)
message là message lỗi.
Sau đó truyền cho hàm như sau :
G_set_error_routine (handler);
int Reset lại cơ chế xử lý lỗi cũ của thư
viện ( sử dụng hai hàm G_fatal_error G_unset_error_routine (void)
Trang 45
và G_warning)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
int flag = 1: in ra thông điệp lỗi và sleep
G_sleep_on_error (int flag)
int - Dùng để “triệt hạ” hàm G_Warning
nếu muốn. (ta sử dụng lại code chương G_suppress_warnings (int flag)
trình đã được viết trước đó và không
muốn hiện thị các message lỗi)
flag = 0:G_Warning sẽ không còn in ra
message được nữa
flag = 1 :G_Warning sẽ in ra message
được nữa
- Hàm này không triệt được
G_fatal_error
(cid:145) Truy xuất biến môi trường và thông tin liên quan đến cơ sở dữ liệu của GRASS
Hàm Chức năng
char * Trả về đường dẫn đến location hiện tại của
Trang 46
database đang làm việc. G_location (void)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
char *
G_location_path (void)
char * Trả ra đường dẫn đến mapset đang làm việc
trong location hiện tại. G_mapset (void)
char * Trả ra dòng tiêu đề của location đang làm việc (
nó đọc từ file MYNAME của MAPSET G_myname (void)
PERMANENT)
char * Trả ra thư mục cài đặt GRASS.
Thư mục cài đặt GRASS sẽ có các thư mục con G_gisbase (void)
sau
bin : Chứa các command có thể gọi trực tiếp
bởi các user
etc : Module và file dữ liệu được sử dụng bởi
các GRASS command
txt : File hướng dẫn
menu : Những file được sử dụng bởi để tạo
menu trong grass3
Ví dụ : để gọi lệnh sroff trong thư mục etc, ta
làm như sau
char command[200];
Trang 47
sprintf (command, "%s/etc/sroff", G_gisbase( )
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
);
system (command);
char * Trả ra thư mục cài đặt các cơ sở dữ liệu của
GRASS. (GRASS có thể có nhiều cơ sở dữ liệu G_gisdbase (void)
nhưng chúng phải được cài đặt nằm trong thư
mục chung này)
Hàm truy xuất biến môi trường GISDBASE
int truy xuất giá trị biến môi trường của GRASS (
biến môi trường GRASS là những biến môi G_getenv (char *name)
trường được quan trọng đối với thư viện và nó
được lưu trong file .grassrc5 )
int Nếu không truyền name là tên biến môi trường:
G_ _getenv (char *name) + G_getenv : sẽ báo lỗi và gọi exit để thoát
+ G__getenv : chỉ báo lỗi nhưng không thoát
int Gán giá trị cho biến môi trường của GRASS.
Thông tin này sẽ lập tức được ghi nhận vào file G_setenv (char *name, char
.grassrc5, để lần sau khi chạy GRASS nó sẽ *value)
được load lên lại. int
Nếu giá trị value là NULL,việc gán biến môi G_ _setenv (char *name,
Trang 48
trường sẽ không được thực hiện. char *value)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
(cid:145) Truy vấn cơ sở dữ liệu GRASS
Hàm Chức năng
Người sử dụng được yêu cầu nhập tên char *
của một file cơ sở dữ liệu đã có. G_ask_old (char *prompt, char
*name, char *element, char *label)
char name[50];
char *mapset;
mapset = G_ask_old ("", name,
"paint/labels", "labels");
if (mapset = = NULL)
exit(0); /* user canceled the request */
Kết quả hiện ra:
Enter the name of an existing labels file
Enter 'list' for a list of existing labels
files
Hit RETURN to cancel request 4
>
Người sử dụng được yêu cầu nhập tên
Trang 49
của một file cơ sở dữ liệu chưa có trước char *
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
đó trong mapset. Tên này được dùng để G_ask_new (char *prompt, char
tạo mới file. *name, char *element, char *label)
char * Trả ra tên file hợp lệ.
Người sử dụng nhập vào một tên file, G_ask_any (char *prompt, char
*name, char *element, char *label,
int warn) Warn = 1 : nếu file đó đã tồn tại, người
sử dụng sẽ được hỏi có muốn ghi đè lên
không ?
Warn = 0 : file đó được chấp nhận và
không có thông điệp hỏi lại dù rằng
trước đó có một file đã mang tên đó
trong mapset.
Trả ra đường dẫn đến file có tên là char *
“name” trong mapset. G_fully_qualified_name (char *name,
char *mapset)
Trang 50
(cid:145) Tìm file dữ liệu trong CSDL
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Hàm Chức năng
Tìm một file dữ liệu của cơ sở dữ liệu char *
char name[50]; G_find_file (char *element, char
*name, char *mapset) char *mapset;
if ((mapset =
G_find_file("paint/labels",name,""))
== NULL)
/* not found */
Kiểm tra coi file đó có tồn tại trong mapset
hiện tại hay không, ta làm như sau :
char name[50];
if
(G_find_file("paint/labels",name,G_mapset(
))
== NULL)
/* not found */
Kiểm tra tên file dữ liệu có hợp lệ không. int
1 : hợp lệ G_legal__lename (char *name)
-1 : không hợp lệ
Trang 51
Mở một file dữ liệu để đọc. int
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
File đữ liệu có tên là “name”, nằm trong G_open_old (char *element, char
“mapset” của Location hiện tại và thuộc *name, char *mapset)
thành phần dữ liệu “element” (thư mục con
element của mapset) .
Hàm dùng open() để cài đặt mở file, trả ra –
1 nếu không có file, ngược lại trả ra id của
file được mở.
Mở một file dữ liệu để đọc. FILE *
Các tham số có nội dung giống hàm G_fopen_old (char *element, char
G_open_old *name, char *mapset)
Hàm này fopen() với tham số “r” để cài đặt,
trả ra NULL nếu không có file, ngược lại trả
ra con trỏ FILE đến file đã được mở.
Mở file có tên name trong “element” của int
mapset hiện tại theo mode cho phép đọc và G_open_update (char *element,
ghi. char *name)
Hàm dùng open() để cài đặt mở file, trả ra –
1 nếu không có file, ngược lại trả ra id của
Trang 52
file được mở.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Mở file có tên name trong “element” của FILE *
mapset hiện tại theo mode append. G_fopen_append (char *element,
char *name)
Hàm này fopen() với tham số “r” để cài đặt,
trả ra NULL nếu không có file, ngược lại trả
ra con trỏ FILE đến file đã được mở.
Tạo mới và mở file dữ liệu “name” theo int
mode write only, trong thư mục “element” G_open_new (char *element, char
của mapset hiện tại. *name)
Dùng hàm open() để cài đặt. Trả ra –1 nếu
thất bại
Tạo mới và mở file dữ liệu “name” theo FILE *
mode write only, trong thư mục “element” G_fopen_new (char *element, char
của mapset hiện tại *name)
Dùng hàm fpen() để cài đặt. Trả ra NULL
nếu thất bại
Đổi tên một file dữ liệu trong thư mục int
element của mapset. G_rename (char *element, char
Kết quả trả về *old, char *new)
Trang 53
1 nếu thành công
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
0 nếu file old không tồn tại
-1 nếu thất bại
int Xoá file trong thư mục element của mapset
hiện tại. G_remove (char *element, char
Kết quả trả về *name)
1 nếu thành công
0 nếu file không tồn tại
-1 nếu thất bại
Cấp phát bộ nhớ
Giải phóng bộ nhớ được cấp phát bằng hàm int
thư viện của GRASS G_free(void *buf)
Thay đổi kích thước vùng nhớ đã được cấp void *
phát trước đó bằng hàm thư viện của G_realloc (void *ptr, int size)
GRASS
ptr trỏ đến vùng nhớ đã được cấp trước đó
size kích thước mới (tính theo bytes)
Trang 54
Kết quả trả về NULL nếu thất bại, ngược lại
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
là con trỏ đến vùng nhớ đã được cấp phát
Cấp phát một vùng nhớ có kích thước void *
n*size bytes, khởi tạo vùng nhớ với giá trị G_calloc (int n, int size)
0.
Kết quả trả về NULL nếu thất bại, ngược lại
là con trỏ đến vùng nhớ đã được cấp phát
double * Cấp phát vùng nhớ cho một mảng số double
có n phần tử, khởi tạo zero cho tất cả phần G_alloc_vector(int n)
tử.
foat * Cấp phát vùng nhớ cho một mảng số float
có n phần tử, khởi tạo zero cho tất cả phần G_alloc_fvector(int n)
tử.
double ** Cấp phát vùng nhớ cho một ma trận double
có rows dòng và cols cột, khởi tạo zero cho G_alloc_matrix(int rows, int cols)
tất cả phần tử.
Cấp phát vùng nhớ cho một ma trận float có float **
rows dòng và cols cột, khởi tạo zero cho tất G_alloc_fmatrix(int rows, int cols)
cả phần tử.
int Giải phóng vùng nhớ cho ma trận float đã
cấp G_free_fmatrix(foat **m)
int Giải phóng vùng nhớ cho ma trận double đã
Trang 55
cấp G_free_matrix(double **m)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
int Giải phóng vùng nhớ cho mảng double đã
cấp G_free_vector(double *v)
(cid:153) REGION
Khái niệm về vùng (region) đã được trình bày trong phần trước, có thể xem nó là một
ma trận hai chiều với kích thước xác định và được phân thành nhiều cell (ô) nhỏ đều
nhau.
Về logic, có hai loại vùng (region) khác nhau trong GRASS : loại thứ nhất là vùng
(region) được xác lập cho CSDL, do người sử dụng thiết lập cho mapset hiện tại. Loại
thứ hai là vùng (region) xử lý được thiết lập cho module của chương trình, nó sẽ điều
khiển quá trình ghi và đọc dữ liệu vào file raster và file site. Những bảng đồ kiểu
vector (vector map) không có loại region xử lý được thiết lập cho module.
Thông tin về một region được lưu trong cấu trúc Cell_header, định nghĩa trong file
“gis.h”
(cid:145) Vùng (region) được xác lập cho CSDL
Chức năng Hàm
Đọc region được lưu trong file WIND int
của MAPSET hiện tại vào trong struct G_get_window (struct Cell_head
region. *region)
Ghi thông tin của vùng (region) chứa int
Trang 56
trong cấu trúc region truyền cho hàm G_put_window (struct Cell_head
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
vào file WIND của MAPSET hiện tại *region)
int Lấy thông tin mặc định về region của
LOCATION hiện tại được chọn. G_get_default_window (struct
Cell_head *region)
(cid:145) Vùng (region) được xác lập ở mức module
Được sử dụng khi cần đọc và ghi dữ liệu raster cũng như site.
Khi khởi tạo, vùng được xác lập ở mức module và vùng được xác lập cho CSDL là
cùng một giá trị, tuy nhiên lập trình viên có thể thay đổi tuỳ biến, thông qua
Chức năng Hàm
Thiết lập region ở mức module xử lý. int
Việc thiết lập này không làm thay đổi G_set_window (struct Cell_head
nội dung của file WIND lưu cấu hình *region)
của region ở mức dữ liệu. Vùng xử lý
được thiết lập này chỉ tồn tại trong quá
trình xử lý của module.
Lấy ra giá trị đã được thiết lập thông int
qua hàm G_set_window bên trên G_get_set_window (struct Cell_head
Trang 57
*region)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
(cid:145) Cơ sở dữ liệu lưu theo kinh-vĩ độ
GRASS hỗ trợ lưu toạ độ theo kinh độ và vĩ độ. Tọa độ x là kinh độ và y là vĩ độ.
Vấn đề phát sinh là việc tính diện tích, chiều dài và xác lập một khu vực theo phép
Euclide cho những loại dữ liệu của GRASS trước đó sẽ không còn đúng cho loại dữ
liệu này nữa.
Trái đất thì cong và bản đồ hiện thị thì lại có dạng phằng và không có thông tin nào để
biểu thị cho độ cong của trái đất. Hai điểm dù thuộc cùng một kinh độ hoặc vĩ độ
nhưng chưa chắc khi vẽ lên bản đồ thì chúng thuộc một đường thẳng vì lý do là độ
cong của trái đất.
GRASS cung cấp thư viện GISLIB để giải quyết các vấn đề trên
Kinh độ và vĩ độ được tính theo “độ”. Vĩ độ Bắc nằm từ 0 đến 90 độ, vĩ độ Nam nằm
từ 0 đến – 90 độ. Kinh độ thì không có giới hạn về độ đo vì kinh độ xuất phát từ hai
cực của trái đất.
Toạ độ được thể hiện theo định dạng ASCII và theo những mẫu sau :
Vĩ độ : dd:mm:ssN hoặc dd:mm:ssS
Kinh độ : dd:mm:ssE hoặc dd:mm:ssW
Độ phân giải của lưới hiện thị (grid resolution) : dd.mm.ss
Ví dụ :
80:30:24N là toạ độ của vĩ độ, có nghĩa là 80 độ (degree), 30 phút (minutes) và
24 giây (second) Bắc
120:15W là tọa độ của kinh độ, có nghĩa là 120 độ (degree), 15 phút (minute)
Trang 58
Tây của đường kinh tuyến chính.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Đó là phương pháp mà GRASS dùng để mã hoá toạ độ theo kinh độ và vĩ độ. GRASS
cung cấp trong thư viện những hàm để thực hiện sự chuyển đổi giữa toạ độ thực về toạ
độ mã hoá này
Hàm Chức năng
Chuyển toạ độ được thể hiện trong biến int
east về dạng ASCII và lưu trong buf. G_format_easting (double east, char
Tọa độ biến east là toạ độ Đông. *buf, int projection)
Chuyển toạ độ được thể hiện trong biến int
north về dạng ASCII và lưu trong buf. G_format_northing (double north,
Tọa độ biến east là toạ độ Bắc char *buf, int projection)
Chuyển độ phân giải về dạng mã hoá int
ASCII và lưu kết quả trong buf G_format_resolution (double
resolution, char *buf, int projection)
Chuyển giá trị mã hoá ASCII về toạ độ int
ban đầu, hàm dùng chuyển cho tọa độ G_scan_easting (char *buf, double
Đông *easting, int projection)
Chuyển giá trị mã hoá ASCII về toạ độ int
Trang 59
ban đầu, hàm dùng chuyển cho tọa độ G_scan_northing (char *buf, double Bắc *northing, int projection)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Chuyển dạng mã hoá ASCII của độ int
phân giải về giá trị ban đầu G_scan_resolution (char *buf, double
*resolution, int projection)
Ví dụ minh hoạ
double north ;
char buf[50] ;
G_scan_northing(buf, north, G_projection( )); /* ASCII to double*/
G_format_northing(north, buf, G_projection( )); /* double to ASCII */
G_format_northing(north, buf, -1); /* double to ASCII */
(cid:145)Tính toán diện tích bản đồ kiểu RASTER
Những phép toán hỗ trợ thực hiện việc tính toán trên bản đồ kiểu raster
Dù lưới được xây dựng từ kinh độ và vĩ độ sẽ không chính xác khi thực hiện việc tính
toán đối với diện tích (do trái đất cong, một điểm thuộc cùng kinh độ chưa chắc là
thẳng hàng, điều tương tự đối với vĩ độ), tuy nhiên với cùng một vĩ độ, các ô của lưới
Trang 60
được tạo ra bởi vĩ độ đó và các kinh độ là bằng nhau về kích thước.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Dựa vào điều này GRASS cung cấp các hàm thư viện sau
Chức năng Hàm
double
Trả ra diện tích (area) được tính bằng m2 của một ô lưới tại một dòng. Giá trị G_area_of_cell_at_row (int row)
này dùng để đo diện tích cho những ô
lưới thuộc cùng một dòng.
Phải được gọi trước khi gọi hàm int
G_area_of_cell_at_row G_begin_cell_area_calculations
(void)
Khởi tạo cho việc tính diện tích một int
ellipse có trục nhỏ là a, tâm sai e2 và s G_begin_zone_area_on_ellipsoid
là gia số cho biết phần ellipse sẽ được (double a, double e2, double s)
tính diện tích ( s =1.0 tính toàn bộ, 0.5
cho một nữa ellipse..)
Diện tích nằm giữa khu vực được xác double
định bởi vĩ độ Bắc và Nam, và lấy theo G_area_for_zone_on_ellipsoid
gia số s được truyền cho hàm (double north, double south)
G_begin_zone_area_on_ellipsoid bên
Trang 61
trên
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Khởi tạo việc tính diện tích cho một mặt int
cầu, với r là bán kính và s là gia số cho G_begin_zone_area_on_sphere
phép tính một phần của mặt cầu đó (ý (double r, double s)
nghĩa s tương tự hàm
G_begin_zone_area_on_ellipsoid )
double
Tính diện tích mặt cầu của khu vực G_area_for_zone_on_sphere (double
nằm giữa vĩ tuyến Bắc và Nam. north, double south)
(cid:145) Tính diện tích đa giác
Có một vấn đề mắc phải đối với hệ toạ độ theo kinh độ và vĩ độ mà các hệ toạ độ
phẳng không gặp đó là : đối với loai bản đồ vector chẳng hạn, dữ liệu đa giác được
lưu là những toạ độ (x,y), đường thẳng tạo thành đa giác sau đó được phát sinh bằng
cách nối liền các tọa độ này. Đối với tọa độ theo kinh độ và vĩ độ, do hình dạng trái đất
tròn nên ta không thể sử dụng đường thẳng để nối liền các toạ độ và tạo ra đa giác. Bề
mặt đa giác cần tính có thể xem là nằm trên bề mặt của một ellipse xác định.
GRASS cung cấp những hàm để tính diện tích cho những đa giác cả trong trường hợp
dùng toạ độ phẳng và toạ độ theo kinh độ - vĩ độ.
Hàm Chức năng
int Khởi động việc tính diện tích cho một
đa giác G_begin_polygon_area_calculations
Trang 62
double Tính diện tích cho một đa giác.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Kết quả trả về có đơn vị tính là mét G_area_of_polygon (double *x,
vuông. double *y, int n)
Truyền vào mảng các toạ độ x, mảng
các toạ độ y và n là số cặp điểm (x,y)
đựơc truyền vào.
Khởi động việc tính diện tích cho một int
ellipse có trục chính là a và tâm sai là G_begin_ellipsoid_polygon_area
e2 (double a, double e2)
double Tính diện tích của đa giác được định n
cặp điểm theo toạ độ kinh độ vĩ độ, G_ellipsoid_polygon_area (double
được truyền vào riêng biệt theo hai *lon, double *lat, int n)
mảng lat (vĩ độ) và long (kinh độ)
Đơn vị của kết quả tính là met vuông
(cid:145)Tính khoảng cách
Việc tính khoảng cách giữa hai điểm cũng gặp khó khăn như đối với tính diện tích bên
trên khi dùng toạ độ theo kinh độ và vĩ độ. GRASS cung cấp hàm để làm việc cho cả
toạ độ phẳng và toạ độ theo kinh độ và vĩ độ
Hàm Chức năng
int Khởi động việc tính toán khoảng cách
Trang 63
G_begin_distance_calculations (void)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Trả ra khoảng cách giữa hai điểm có toạ double
độ là x1,y1 và x2,y2. Đơn vị tính là mét G_distance (double x1, y1, x2, y2)
int Bắt đầu việc tính toán dựa trên một
ellipse có trục lớn a và tâm sai e2. Chỉ G_begin_geodesic_distance (double a,
dùng tính đối với toạ độ theo kinh độ và double e2)
vĩ độ.
double Đo khoảng cách giữa hai toạ độ được
tính theo kinh độ và vĩ độ. Đơn vị tính G_geodesic_distance (double lon1,
của khoảng cách là mét. double lat1, double lon2, double lat2)
(cid:145)Xử lý đối với file dữ liệu RASTER
File dữ liệu RASTER là trái tim và linh hồn của GRASS (heart and soul). Do đó mà
GRASS cung cấp cả một thư viện hàm để xử lý cho raster file, bao gồm :
• Xác định file dữ liệu raster sẽ được xử lý (do người dùng xác lập đường dẫn
hay được module tự xác định)
• Định vị file raster trong cơ sở dữ liệu.
• Mở file raster
• Cấp phát buffer để giao tiếp IO
• Các thao tác mở , ghi , đọc và đóng
• Hỗ trợ tạo lập file raster
Trang 64
File raster là file nhị phân chứa cấu trúc CELL (được định nghĩ trong file header gis.h)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Hàm Ý nghĩa
Yêu cầu người dùng nhập vào tên của char *
file raster đã tồn tại trong bất kỳ mapset G_ask_cell_old (char *prompt, char
nào trong cơ sở dữ liệu *name)
char * Yêu cầu người dùng nhập vào tên của
file raster đã tồn tại trong mapset hiện G_ask_cell_in_mapset (char
tại trong cơ sở dữ liệu *prompt, char *name)
Yêu cầu người dùng nhập vào tên của char *
file raster chưa có trong mapset hiện tại G_ask_cell_new (char *prompt, char
trong cơ sở dữ liệu *name)
Tìm file raster có tên là “name” trong char *
một “mapset”. Biến mapset là “” sẽ có ý G_find_cell (char *name, char
nghĩa là tìm kiếm trong toàn bộ các *mapset)
mapset hiện hữu trong CSDL. Nếu tìm
thấy trả ra đường dẫn đến mapset đó,
không thì trả ra NULL.
char name[50];
char *mapset;
if ((mapset = G_find_cell(name,"")) =
= NULL)
Trang 65
/* not found */
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
FILE * Tạo lập và mở theo mode write một file
raster mới. G_open_cell_new (char *name)
CELL * Cấp phát bộ nhớ cho một cấu trúc
CELL. Cấu trúc này là cấu trúc dùng để G_allocate_cell_buf (void)
ghi/đọc vào/từ file raster.
int
Gán giá trị 0 cho tất cả các trường trong G_zero_cell_buf (CELL *buf)
CELL
Đọc một row từ file raster int
G_get_map_row (int fd, CELL *cell,
int row)
Đọc một row từ file raster và không sử int
dụng “mặt nạ”. G_get_map_row_nomask (int fd,
CELL *cell, int row)
Ghi vào file raster int
int fd, row, nrows, ncols; G_put_map_row (int fd, CELL *buf)
CELL *buf;
fd =G_open_cell_new(name);
if (fd < 0) ERROR}
Trang 66
buf = G_allocate_cell_buf();
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
ncols =G_window_cols();
nrows = G_window_rows();
for (row = 0; row < nrows; row++)
{
/* prepare data for this row into buf */
/* write the data for the row */
G_put_map_row(fd, buf);
}
Đóng một file raster int
G_close_cell (int fd)
Nếu có lỗi phát sinh trong quá trình xử int
lý, ta dùng hàm này để đóng file raster G_unopen_cell (int fd)
lại.
(cid:145) Các xử lý khác dành cho RASTER
Như đã đề cập bên trên, một bản đồ có nhiều file dữ liệu khác nhau, có cùng tên với
bản đồ phối hợp với nhau để thể hiện, dữ liệu raster cũng vậy. Những file này được gọi
là những “file hỗ trợ”, supported files, đối với RASTER những file hỗ trợ bao gồm :
• File header
• File danh mục (category)
Trang 67
• File lưu bảng màu
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
• File lưu vết (history)
• File lưu phạm vi (range file)
• File histogram
Mỗi loại file hỗ trợ trên có cấu trúc khác nhau và được thao tác bằng những nhóm hàm
khác nhau thiết kế chuyên biệt cho chúng
Ví dụ : file header có hàm
int G_get_cellhd (char *name, char *mapset, struct Cell_Head *cellhd)
dùng để đọc một cấu trúc header
Một số hàm dùng thao tác với các file hỗ trợ :
Ý NGHĨA HÀM
int
Đọc thông tin header của file raster có G_get_cellhd (char *name, char
tên là name trong mapset vào cấu trúc *mapset, struct Cell_Head *cellhd)
Cell_Head
Viết header của bản đồ có tên là name char *
trong mapset hiện tại vào file header. G_put_cellhd (char *name, struct
Cell_Head *cellhd)
Đọc thông tin của file danh mục int
(category files) name trong mapset vào G_read_cats (char *name, char
Trang 68
trong cấu trúc cats. *mapset, struct Categories *cats)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
int Viết thông tin trong cấu trúc cats vào
cho file raster có tên name. G_write_cats (char *name, struct
Categories *cats)
char * Tìm trong cấu trúc cats, tại danh mục n
và trả ra con trỏ đến một chuỗi qui ứơc G_get_cat (CELL n, struct
của danh mục đó. Categories *cats)
int Để tạo mới một danh mục, trước hết nó
phải được khởi tạo bằng hàm này. G_init_cats (CELL n, char *title,
struct Categories *cats)
int Đặt chuỗi qui ước (label) cho danh mục
n trong cấu trúc cats (cấu trúc quản lý G_set_cat (CELL n, char *label,
các danh mục) struct Categories *cats)
int Giải phóng vùng nhớ được cấp phát cho
cấu trúc cats. G_free_cats (struct Categories *cats)
int Đọc bảng màu của file raster có tên
name của mapset vào biến cấu trúc G_read_colors (char *name, char
dùng quản lý bảng màu colors. *mapset, struct Colors *colors)
Ghi biến cấu trúc colors dùng quản lý int
bản màu cho file raster name của G_write_colors (char *name, char
Trang 69
mapset *mapset, struct Colors *colors)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
int Lấy ra mảng màu cho mảng các giá trị
raster. Hàm nhận vào một mảng (n phần G_lookup_colors (CELL *raster,
tử) các giá trị raster (CELL *raster) và unsigned char *red, unsigned char
trả ra mảng các màu ( 3 mảng) tương *green, unsigned char *blue, set, int
ứng cho các giá trị này. n, struct Colors *colors)
Tìm trong cấu trúc quản lý màu colors int
của file raster và lấy ra 3 thành phần G_get_color (CELL cat, int *red, int
màu RGB : red, green, và blue tương *green, int *blue, struct Colors
ứng cho một giá trị CELL *colors)
int Khởi tạo cho cấu trúc colors.
G_init_colors (struct Colors *colors)
int Giải phóng bộ nhớ được cấp phát cho
cấu trúc colors. G_free_colors (struct Colors *colors)
int Đọc thông tin lưu vết (history info) của
một file raster trong mapset vào cấu trúc G_read_history (char *name, char
quản lý lưu vết history. *mapset, struct History *history)
Viết thông tin lưu vết (history info) của int
một file raster trong mapset vào cấu trúc G_write_history (char *name, struct
Trang 70
quản lý lưu vết history. History *history)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Đọc thông tin về phạm vi của một file int
raster trong mapset và lưu vào cấu trúc G_read_range (char *name, char
range. *mapset, struct Range *range)
Ghi thông tin về phạm vi của một file int
raster trong mapset và lưu vào cấu trúc G_write_range (char *name, struct
range. Range *range)
Khởi tạo cho một cấu trúc range int
G_init_range (struct Range *range)
Khởi tạo cho cấu trúc trạng thái của một int
cell trong bản đồ raster Cell_stats G_init_cell_stats (struct Cell_stats
*s)
Giải phóng vùng nhớ được cấp cho int
Cell_stats G_free_cell_stats (struct Cell_stats
*s)
Cập nhật mảng data (có n giá trị) vào int
cấu trúc quản lý Cell_stats. G_update_cell_stats (CELL *data,
int n, struct Cell_stats *s)
Trang 71
(cid:145) Xử lý cho file Vector
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Thư viện GIS chứa một vài phương thức phục vụ cho việc xử lý file vector. Những
hàm này cung cấp các chức năng cho phép người sử dụng quản lý, xác định file vector
trong cơ sở dữ liệu, và một số chức năng khác..
Ý NGHĨA HÀM
Đọc thông tin danh mục của file vector int
tên là name trong mapset vào cấu trúc G_read_vector_cats (char *name,
quản lý danh mục cats name *mapset, struct Categories
*cats)
Ghi thông tin danh mục của file vector int
tên là name trong mapset vào cấu trúc G_write_vector_cats (char *name,
quản lý danh mục cats struct Categories *cats)
Tạo mới một file vector trong mapset FILE *
hiện tại G_fopen_vector_new (char *name)
FILE * Mở một file vector đã có trước đó trong
mapset hiện tại. G_fopen_vector_old (char *name,
char *mapset)
Tìm một file vector có tên là name int
trong mapset được chỉ định. G_find_vector (char *name, char
char name[50]; *mapset)
Trang 72
char *mapset;
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
if ((mapset = G_find_vector(name,î î))
= = NULL)
/* not found */
(cid:145) Xử lý cho file SITES
Các file site chứa các record mô tả thông tin liên quan đến “điểm”.
Có ba loại record : record ghi chú (comment record), header record, và record dữ liệu
(data record). Những record được ghi trong những file sử dụng bảng mã ASCII và
phân cách nhau bằng ký tự newline của bẳng mã ASCII (0x0A, tương đương ký tự
‘\n’).
Các record được chia làm hai phần, phần 1 chứa thông tin location (2, hoặc 3 field) và
phần 2 chứa các thông tin thuộc tin của vùng location này. Các field có chiều dài
không cố định nên do đó kích thước của các record có thể khác nhau.
Trong phần 1, các field được phân cách bằng ký tự pipe ( | ) có mã ASCII là 0x7c. Ký
tự pipe cuối cùng trong record là ký tự phân cách giữa phần 1 và phần 2
Trong phần 2, tùy vào loại thuộc tính sẽ sử dụng ký tự phân cách khác nhau
• Thuộc tính danh mục (Category attribute) : sử dụng ký tự # làm tiền tố, số
chỉ mục là số nguyên.
• Thuộc tính thập phân (decimal attribute) : sử dụng ký tự % làm tiền tố.
• Thuộc tính chuỗi (String attribute) : sử dụng tiền tố @ và chuỗi được bao
trong ngoặc kép “
• Thuộc tính mặc định : nếu không có các tiền tố #,@ và %, kiểu của thuộc
tính mặc định là chuỗi (string)
Trang 73
Ví dụ :
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
name|time
desc|Example of using time as an attribute
time|Mon Apr 17 14:24:06 EST 1995
10.8|0|9.8|Fri Sep 13 10:00:00 1986 %31.4
11|5.5|9.9|Fri Sep 14 00:20:00 1985 %36.4
5.1|3.9|10|Fri Sep 15 00:00:30 1984 %28.4
Với dữ liệu trên, mỗi record dữ liệu
Trong phần I có 3 thuộc tính xác lập toạ độ của vùng Location. (record 1 : 10.8 | 0 | 9.8
)
Trong phần 2 có 5 thuộc tính chuỗi, và 1 thuộc tính thập phân ( record 1 : 5 thuộc tính
được hiểu mặc định là chuỗi là : Fri, Sep, 13, 10:00:00 và 1986; thuộc tính thập phân là
3.14)
HÀM Ý NGHĨA
Yêu cầu người sử dụng nhập vào tên char *
của một file site trong danh sách các file G_ask_sites_old (char *prompt,
site đã có sẵn. char *name)
char *mapset;
char name[50];
mapset = G_ask_sites_old("Enter site
Trang 74
list file to be processed", name);
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
if (mapset == NULL)
exit(0);
Tạo mới file site FILE *
G_sites_open_new (char *name)
Mở một file site đã có sẵn FILE *
G_sites_open_old (char *name, char
*mapset)
Cấp phát bộ nhớ, tạo mới một cấu trúc Site *
Site G_site_new_struct
(RASTER_MAP_TYPE c, int n, int s,
int d)
Giải phóng vùng nhớ đã được cấp phát void
trước đó. G_site_free_struct (Site *site)
Đọc một site record từ file đã được mở. int
G_site_get (FILE *fd, Site *s)
Ghi một site record vào . int
G_site_put (FILE *fd, Site *s)
(cid:145) Các hàm dùng vẽ cơ bản
Thư viện GIS còn cung cấp các hàm dùng để thực hiện các thao tác vẽ đường thẳng và
Trang 75
đa giác cơ bản . Sau đây là một số hàm :
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Ý NGHĨA HÀM
Hàm vẽ đường thẳng, sử dụng thuật int
toán Breshenham. G_bresenham_line (int x1, int y1, int
Trong đó, hàm dùng để vẽ 1 point phải x2, int y2, int (*point)( ) )
tự cài đặt và truyền vào thông qua con
trỏ hàm
int (*point)()
Hàm khởi tạo cho một quá trình vẽ. int
Hàm này phải được gọi trước khi bắt G_setup_plot (double t, double b,
đầu gọi bất cứ hàm nào có tên theo mẫu double l, double r, nt (*Move)( ), int
G_plot_* (*Cont)( ))
t,b,l và r là tọa độ các điểm top, bottom,
left và right của vùng vẽ.
Hàm nhận vào hai con trỏ hàm đến hai
hàm được người dùng tự cài đặt :
Move(x, y) di chuyển đến toạ độ (x,y)
Cont(x, y) vẽ đến toạ độ x,y từ toạ độ
trước đó.
Hàm này chịu trách nhiệm “xén” nếu
(x,y) nằm ngoài vùng được phép vẽ.
int Vẽ một đường thẳng, truyền vào toạ độ
Trang 76
tính theo kinh độ và vĩ độ. G_plot_line (double east1, double
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
north1, double east2, double north2)
int Vẽ đa giác n cạnh, truyền vào toạ độ
tính theo kinh độ và vĩ độ G_plot_polygon (double *east, double
*north, int n)
(cid:145) Sử dụng file tạm
Đôi khi trong quá trình xử lý của mình, các module cần lưu các thông tin tạm vào một
file. Sau khi module đó được xử lý xong, các thông tin tạm đó không cần nữa và file
lưu các thông tin tạm sẽ được xoá đi. Vấn đề cần giải quyết ở đây là cơ chế cung cấp
tên file dùng để lưu các thông tin tạm này, tên file này buộc phải là duy nhất nghĩa là
không được trùng với các file cũng dùng các thông tin tạm khác. GRASS cung cấp một
hàm đảm bảo điều này :
Trả ra một tên file dùng lưu dữ liệu tạm char *
G_temp_le ( )
GRASS dựa vào id của process đang chạy để cung cấp tên cho file tạm, khi process
này không còn chạy nữa, tiến trình quản lý cơ sở dữ liệu của GRASS sẽ tự động xoá
những file tạm này đi.
(cid:145) Hỗ trợ các lệnh command
Mỗi lệnh (command) trong GRASS có thể sẽ đòi hỏi truyền các tham số vào. Người
dùng có tràch nhiệm phải cung cấp đầy đủ các tham số này, nếu không, “lệnh” sẽ
Trang 77
không thực hiện được và sẽ cung cấp hướng dẫn sử dụng kèm theo thông báo lỗi.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Để chuẩn hoá qui trình cung cấp thông tin và kèm theo thông báo lỗi khi người dùng
cung cấp các tham số không đúng, GRASS hỗ trợ một số hàm cho lập trình viên và
khuyến cáo các lập trình viên nên tận dụng nó khi viết các lệnh mới.
Sử dụng hai cấu trúc
struct Option *opt; /* mô tả các tùy chọn của lệnh */
Chi tiết :
opt->key Tên của tùy chọn
opt->description Dòng mô tả cho user về tùy chọn này
opt->type Kiểu dữ liệu user sẽ cung cấp cho tùy chọn này
opt->required Lệnh có bắt buộc phải có option này ?
struct Flag *flag; /* Các cờ hiệu */
Chi tiết :
flag->key Một ký tự đơn dùng làm cờ hiệu
flag->description Thông tin về cờ cho user
Hàm Ý nghĩa
struct Option * Cấp phát bộ nhớ cho một cấu trúc
option G_define_option ( )
struct Flag * Cấp phát bộ nhớ cho một cấu trúc flag
Trang 78
G_define_flag ( )
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
int Phân tích các tham số do user truyền
vào. Trả ra 0 nếu thoả mãn yêu cầu về G_parser (int argc, char *argv[ ])
các tham số của lệnh.
int In thông tin hướng dẫn sử dụng lệnh
cho user. Khi check G_parser không G_usage ( )
thành công, lập trình viên có thể gọi
hàm này để hướng dẫn người sử dụng
(cid:145) Làm việc với UNIX/LINUX
Vì thư viện GRASS được phát triển và hỗ trợ mạnh cho LINUX/UNIX, nên nó cung
cấp một số hàm chuyên biệt để lập trình trên hệ điều hành này.
Lập trình đa tiến trình :
LINUX/UNIX cung cấp hàm fork() để tạo tiến trình con là một bản sao của tiến trình
cha. Việc tạo tiến trình con thông thường dùng để chuyển các công việc của module về
“hậu trường”.
Kỹ thuật thường dùng trong LINUX/UNIX là gọi fork() để tạo ra một tiến trình con,
khi tiến trình con được tạo lập thành công, tiến trình cha lập tức gọi exit() để thoát và
từ đó trở đi, tiến trình con chạy “hậu trường” độc lập.
Tuy nhiên, GRASS gặp một vấn đề nhỏ với điều này, đó là trong UNIX/LINUX người
dùng có thể sử dụng các thao tác bàn phím để kill một process đang chạy và vì thế có
khả năng một module xử lý quan trọng đang làm việc ở “hậu trường” sẽ không đảm
bảo thực hiện đầy đủ nhiệm vụ được giao. GRASS giải quyết vấn đề này bằng cách
Trang 79
cung cấp hàm G_fork().
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
pid_t G_fork ( ) : Tạo một process con và trả ra id của nó. Hàm sẽ chuyển process con
được tạo ra vào một group process, đảm bảo không bị vô ý kill bởi người dùng khi
chưa hoàn thành nhiệm vụ.
Lập trình với socket trong UNIX
Các hàm cung cấp bởi GRASS cho công việc này đều có dạng G_sock_*, đóng gói
việc lập trình socket trên UNIX, đơn giản hóa các thao tác cho lập trình viên
Ý nghĩa Hàm
Nhận vào name của kênh truyền dẫn và char *
trả ra đường dẫn full đến socket file G_sock_get_fname (char *name)
dùng để truyền dẫn.
Truyền vào name là đường dẫn full đến int
socket file của kênh truyền dẫn, kiểm G_sock_exists (char *name)
tra xem socket đó có tồn tại
Kết nối với một socket file. int
G_sock_bind (char *name)
“Nghe” trên một socket int
G_sock_listen (int fd, unsigned int
queue)
Chấp nhận một kết nối, tham số fd là int
Trang 80
kết quả trả về của G_sock_listen G_sock_accept (int fd)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
int
Socket client tìm cách connect với G_sock_connect (char *name)
socket server
(cid:153) Thư viện VASK
VASK - viết tắt của cụm từ visual ask. Thư viện cung cấp một cách thức đơn giản để
giao tiếp với người sử dụng. Một trang màn hình chứa các thông tin cùng các câu hỏi
được hiện thị và người dùng được yêu cầu nhập các thông tin cần thiết cho chúng.
Cách thức giao tiếp với người dùng này thường thấy ở các module chương trình của
GRASS.
VASK là một thư viện hỗ trợ lập trình viên tạo ra sự giao tiếp này. Các hàm của thư
viện có tiền tố bắt đầu là V_*
Ý nghĩa Hàm
Khởi tạo int
V_clear ()
Viết một dòng text tại dòng num. Dòng int
có giá trị từ 0 đến 22. Dòng 0 là dòng V_line (int num, char *text)
trên cùng của màn hình
Ctype có kiểu là integer, long, float, int
Trang 81
double hoặc char. V_const (Ctype *value, char type, int
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Type dùng các ký tự để xác định kiểu row, int col, int len)
dữ liệu của con trỏ value : ‘i’ (integer),
‘d’ (double), ‘f’ (float), ‘l’ (long) hoặc int ‘s’ (char string).
V_ques (Ctype *value, char type, int Row có giá trị từ 0 .. 22 row, int col, int len)
Col có giá trị từ 0 .. 79
Người dùng được yêu cầu nhập liệu, ô
nhập liệu nằm tại vị trí col, row và có
chiều dài len. Nội dung nhập liệu của
người dùng chứa trong biến value
Giao tiếp với người sử dụng. int
Khi được gọi, nó sẽ lau màn hình và V_call ()
hiện thị các nội dung đã đựơc chỉ định
bởi V_line, V_ques và V_const.
# define LEN 15
..
/* các biến*/
int i ;
foat f ;
char s[LEN] ;
Trang 82
Ví dụ minh họa :
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
/*Khởi tạo giá trị các biến */
i=0;
f = 0.0 ;
*s = 0 ;
/* khởi tạo vask info*/
V_clear( ) ;
/* Vùng text hiện thị */
V_line( 5, “ Enter an Integer “) ;
V_line( 7, “ Enter a Decimal “) ;
V_line( 9, “ Enter a character string “) ;
/* Vùng yêu cầu người dùng nhập liệu*/
V_ques ( &i, 'i', 5, 30, 5) ;
V_ques ( &f, 'f', 7, 30, 5) ;
V_ques ( s, 's', 9, 30, LEN - 1) ;
/* Hiện thị các thông tin bên trên và chờ thao tác nhập liệu của người dùng*/
if (!V_call( ))
Trang 83
(cid:153) Thư viện làm việc với các bản đồ kiểu VECTOR
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Thư viện này cung cấp các hàm để làm việc với các file nhị phân lưu thông tin của các
bản đồ kiểu vector.
Các hàm có tiền tố bắt đầu là Vect_ hoặc V1_ hoặc V2_ hoặc dig_.
Để sử dụng thư viện, ta phải thực hiện
#include
vào module cần sử dụng.
Các vector có dữ liệu được mã hoá theo ba cấu trúc : LINE, AREA và DOT được định
nghĩa trong “dig_define.h” và file này được tự động include trong file “Vect.h”.
Có hai mức truy xuất đối với các file thông tin của bản đồ VECTOR :
• Mức 1 : các thông tin giới hạn như thông tin các cung của bản đồ vector.
Các thông tin đồ hình, danh mục .. không được truy xuất ở mức này.
• Mức 2 : Hỗ trợ truy xuất toàn diện tất cả các thông tin. Cần nhiều bộ nhớ,
xử lý và tốn nhiều thời gian hơn.
Ý nghĩa Hàm
Mở bản đồ vector có tên là name trong int
mapset . Mở để đọc. Vect_open_old (struct Map_info
*Map, char *name, char *mapset)
Mở bản đồ vector có tên là name trong int
mapset hiện tại . Mở để ghi Vect_open_new (struct Map_info
*Map, char *name)
Xác lập mức truy xuất ( như đã trình int
Trang 84
bày bên trên, chúng ta có 2 mức truy
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
xuất đối với dữ liệu bản đồ vector) Vect_set_open_level (int level)
Đóng bảng đồ lại int
Vect_close (struct Map_info *Map)
int Kết quả trả về là –2 : EOF, -1 : Lỗi.
Đây là hàm chính để thao tác, nó đọc Vect_read_next_line (struct
dòng tiếp theo từ Map vào Point. Map_info *Map, struct line_pnts
*Points)
Ghi vào bảng đồ vector. long
Phải được mở bằng Vect_open_new Vect_write_line (struct Map_info
trước đó. *Map, int type, struct line_pnts
*Points)
struct line_pnts * Khởi tạo, cấp phát bộ nhớ cho một
struct line Vect_new_line_struct (void)
int Huỷ bộ nhớ đã cấp trước đó cho struct
line. Vect_destroy_line_struct (struct
line_pnts *Points)
#include “Vect.h” /* new include file */
struct Map_info Map;
/* Map info */
Trang 85
Ví dụ :
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
struct line_pnts *Points;
/* Poly-Line data */
G_gisinit (argv[0]);
/* init GIS lib */
if (Vect_open_old (&Map, name, mapset) < 0 ) /* open file */
G_fatal_error (“Cannot open vector file”);
Points = Vect_new_line_struct (‘h'|209350u');
while ( Vect_read_next_line (&Map, Points) > 0 ) /* loop reading*/
{
/* each line */
/* do something with Points */
}
Vect_destroy_line_struct (Points); /* remove allocation */
Vect_close (&Map); /* close up */
(cid:153) Thư viện đồ họa cho RASTER (RASTER GRAPHICS LIBRARY)
Mọi giao tiếp đồ hoạ đều thông qua thư viện này trực tiếp hay gián tiếp. Thư viện này
được thiết kế độc lập với thiết bị đồ hoạ, nó thực hiện chức năng đồ hoạ bằng cách gọi
một tập hàm được đặt tả và loại thiết bị đồ hoạ buộc phải có một driver, cài đặt tập hàm
theo đặc tả trên. Thiết bị đồ hoạ ở đây có thể hiểu là môi trường dùng hiện thị, vì
GRASS phát triển trên nền UNIX/LINUX nên không có khái niệm device contex (DC)
như trong Windowx, thiết bị hiện thị vì thế tách bạch rõ có thể là một máy in, màn hình
máy tính , có thể là hiện thị trên Windows, hoặc trên XWindows .. Dù hiện thị trên
thiết bị nào, thiết bị hiện thị đó buộc phải cung cấp driver (tập hàm giao tiếp) theo đặc
Trang 86
tả của thư viện.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Một số điều cần lưu ý :
• Thư viện vẫn duy trì khái niệm vị trí hiện tại (current position). Mặc dù trên
màn hình hiện thị, vị trí hiện tại không có dấu hiệu gì đặc biệt nhưng có rất
nhiều hàm đồ họa sử dụng thông tin vị trí hiện tại để thực hiện tác vụ đồ hoạ
của nó.
• Thư viện vẫn duy trì khái niệm màu hiện tại được chọn (current chosen
color).
Lập trình viên phải định nghĩa tọa độ trên màn hình một cách tường minh cho một tác
vụ đồ hoạ. Góc toạ độ của màn hình được xác định là góc trái trên cùng (top left
corner). Các thông tin về vùng hiện thị có thể được lấy thông qua hàm R_screen_left,
R_screen_rite, R_screen_top và R_screen_bot.
Kết nối với driver hiện thị
int
Hàm Chức năng
Trước khi thực hiện bất cứ tác vụ đồ
hoạ nào, ta phải kết nối với driver hiện
R_open_driver ( )
thị.
Hàm này được gọi trong lệnh d.mon và
chỉ một ứng dụng được phép kết nối với
int
một driver hiện thị tại một thời điểm.
Đóng driver
R_close_driver ( )
Trang 87
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Bảng màu
Có hai chế độ màu :
• Bảng màu cố định (fixed color) : Dùng bảng màu được thiết lập theo bảng
màu thiết bị hiện thị và không cho phép thay đổi.
• Bảng màu thay đổi được : Cũng dùng bảng màu được thiết lập theo bảng
màu thiết bị hiện thị nhưng cho phép thay đổi, tùy biến thông qua lệnh
d.color.
Hàm Chức năng
int Chọn sử dụng bảng màu cố định cho
những tác vụ đồ họa đi theo sau. R_color_table__fixed ( )
int Chọn sử dụng bảng màu có thể thay đổi
cho những tác vụ đồ họa đi theo sau. R_color_table_float ( )
int Định nghĩa màu có thứ tự num trong
bảng màu R_reset_color (unsigned char red,
unsigned char green, unsigned char
blu, int num)
int Chọn màu color sẽ sử dụng cho những
tác vụ đồ hoạ đi theo sau. R_color (int color)
int Khi loại bảng màu có thể thay đổi được
Trang 88
lựa chọn, lời gọi hàm này sẽ chọn màu R_RGB_color (int red, int green, int
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
gần với màu được yêu cầu nhất cho blue)
những tác vụ đồ hoạ đi theo sau.
Giá trị red, green và blue là 0..255
Các hàm vẽ cơ bản
Hàm Ý nghĩa
int Trả ra chỉ số dòng pixel của cạnh dưới
cùng màn hình hiện thị. R_screen_bot ( )
Trả ra chỉ số dòng pixel của cạnh trên int
cùng màn hình hiện thị. R_screen_top ( )
Trả ra chỉ số dòng pixel của cạnh bên int
trái màn hình hiện thị. R_screen_left ( )
Trả ra chỉ số dòng pixel của cạnh bên int
phải màn hình hiện thị. R_screen_rite( )
Di chuyển vị trí hiện tại đến x,y int
Trang 89
R_move_abs (int x, int y)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Vẽ một đường thẳng từ vị trí hiện tại int
đến x,y R_cont_abs (int x, int y)
Vẽ và tô màu một hình chữ nhật. Màu int
tô là màu hiện tại R_box_abs (int x1, int y1, int x2, int
y2)
Xoá màn hình int
R_erase ( )
Đồng bộ hoá việc hiện thị. int
Gửi tất cả các lệnh đồ hoạ còn tồn đến R_stabilize ( )
driver và buộc các lệnh còn tồn phải
được driver thực hiện
Vẽ một loạt điểm có toạ độ x,y được int
truyền cho hàm, num là số điểm phải R_polydots_abs (int *x, int *y, int
vẽ. num)
Toạ độ của vị trí hiện tại sẽ được cập
nhật thành điểm cuối cùng được vẽ của
hàm
Màu sử dụng là màu hiện tại
Vẽ một đa giác đóng. Num là số đỉnh
của đa giác. Toạ độ của các đỉnh là hai int
mảng x, y được truyền cho hàm. R_polygon_abs (int *x, int *y,int
Trang 90
Toạ độ của vị trí hiện tại sẽ được cập
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
nhật thành điểm cuối cùng được vẽ của num)
hàm
Màu sử dụng là màu hiện tại
int Vẽ một loạt đường theo các toạ độ được
chỉ định, các đường này không tạo R_polyline_abs (int *x, int *y, int
thành đa giác đóng. num)
Toạ độ của vị trí hiện tại sẽ được cập
nhật thành điểm cuối cùng được vẽ của
hàm
Màu sử dụng là màu hiện tại
int
Vẽ raster R_raster (int num, int nrows, int
withzero, int *raster) Bắt đầu tại vị trí hiện tại, tham số num
thể hiện số màu tương ứng với giá trị
trong mảng raster, được dùng để vẽ
nrows dòng pixel liên tục nhau. Tham
số withzero xác định liệu giá trị 0 có
thể xem là một màu hay là bỏ qua
Xác định cái khung hiện thị text int
R_set_window (int top, int bottom,
Trang 91
int left, int right)
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Chọn Font chữ . int
Các Font chữ được phép chọn R_font (char *font)
Xác lập kích thước text int
R_text_size (int width, int height)
Dùng Font, màu, kích thước text và vị int
trí hiện tại, xuất một text ra. R_text (char *text)
Chọn một location bằng mouse. int
Trước hết, cursor sẽ được đặt tại vị trí R_get_location_with_pointer (int *nx,
nx, ny được truyền vào. Sau đó khi int *ny, int *button)
button chuột được nhấn, vị trí chuột
được ghi nhận vào nx, ny và thông tin
button nhấn được ghi nhận vào button.
Dựa vào nx , ny ban đầu và nx,ny trả về
ta xác định được location được chọn
Tương tự như trên nhưng lần này một int
line cố định một đầu tại x,y và vị trí R_get_location_with_line (int x, int y,
nx,ny được xác định khi mouse được int *nx, int *ny, int *button)
nhấn.
Tương tự như trên nhưng lần này một int
rectangle thay vì một line, cố định một R_get_location_with_box (int x, int y,
Trang 92
đầu tại x,y và vị trí nx,ny được xác định
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
khi mouse được nhấn int *nx, int *ny, int *button)
(cid:153) Thư viện hiện thị đồ họa (DISPLAY GRAPHICS LIBRARY)
Cung cấp các hàm đồ họa bao bọc ở một mức cao hơn, các hàm này sử dụng các hàm
được cung cấp từ thư viện đồ họa raster để thực hiện các tác vụ đồ hoạ. Có thể xem các
hàm đồ hoạ của thư viện đồ họa raster là các hàm đồ hoạ chính yếu, còn các hàm đồ
họa của thư viện này phối hợp các hàm chính yếu đó để tạo ra những hàm chuyên dụng
cho GRASS.
Các hàm được thiết kế theo 4 hướng :
• Tạo lập và quản lý các cửa sổ hiện thị.
• Chuyển đổi toạ độ.
• Hiện thị các raster.
• Các tác vụ linh tinh khác: popup menu, xén hình ...
Các hàm của thư viện có tiền tố bắt đầu là D_*
Hàm Ý nghĩa
Khởi tạo cho một cửa sổ hiện thị hiện int
tại. D_setup (int clear)
clear = 1 : xoá toàn bộ nội dung trên
cửa sổ
Trang 93
int Tạo mới một cửa sổ hiện thị.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
D_new_window (char *name, int top,
int bottom, int left, int right)
Chọn cửa sổ hiện thị có tên được xác int
lập trong tham số name làm cửa sổ hiện D_set_cur_wind (char *name)
thị hiện tại.
Lấy ra tên của cửa sổ được chọn hiện int
tại. D_get_cur_wind (char *name)
Vẽ viền (outline) cửa sổ hiện tại với int
màu được chọn là color. D_show_window (int color)
Danh sách màu được định nghĩa trong
file color.h
Lấy ra toạ độ của cửa sổ hiện thị, lưu int
vào bốn tham số : top, bottom, left và D_get_screen_window (int *top, int
right. *bottom, int *left, int *right)
Xoá nội dung đang hiện thị trên màn int
hình D_erase_window ( )
Xoá tất cả thông tin liên quan đến cửa int
sổ hiện thị hiện tại, bao gồm các thông D_clear_window ( )
tin về vùng bản đồ hiện thị và nội dung
danh sách hịên thị của cửa sổ.
Trang 94
Thêm một lệnh (command) vào danh int
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
sách hiện thị của cửa sổ D_add_to_list (char *string)
Lưu trữ tên của bản đồ raster thành int
thông tin đi kèm với cửa sổ hiện thị D_set_cell_name (char *name)
hiện tại.
int
Xác lập tên bản đồ vector trong danh sách
Lấy ra tên bản đồ đã được lưu với cửa D_get_cell_name (char *name) sổ hiện thị hiện tại trước đó.
hiện thị
int
Lấy ra tên bản đồ vector được hiện thị
D_set_dig_name (char *name)
int
Xác lập tên bản đồ site trong danh sách
D_get_dig_name (char *name)
hiện thị
int
D_set_site_name (char *name)
Lấy ra tên bản đồ site được hiện thị int
Xoá thông tin danh sách hiện thị của cửa sổ
D_get_site_name (char *name)
int
D_clear_window ( )
2.9 Cơ chế bổ sung và quản lý mã nguồn của GRASS Vì GRASS là một dự án mở, có sự đóng góp từ nhiều lập trình viên, tổ chức .. do đó, nó phải có cơ chế thống nhất để quản lý và phát triển mã nguồn.
Trang 95
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
2.9.1 Mã nguồn chính thức (thư mục src)
Một mã nguồn muốn vào được thư mục src, tức trở thành mã nguồn chính thức của GRASS, nó phải vượt qua được những yêu cầu khắc khe sau :
1. Ổn định, ít thay đổi thường xuyên
2. Khả năng có thể “sống sót” đã được chứng minh – mã nguồn đó phải sống sót trong phiên bản ALPHA của GRASS ít nhất 1 năm. Một cách tương đối nhằm đảm bảo tất cả các bug đã được tìm thấy và sửa chữa.
3. Vượt qua các yêu cầu nghiêm ngặt đối với một phiên bản ALPHA
4. Được OGI chứng nhận, OGI ( Office of GRASS Integration) là Cơ quan chuyên lo chuyện tích hợp và chứng nhận các mã nguồn mới của GRASS.
Tóm lại, những mã nguồn đã sống sót qua một năm ở phiên bảng ALPHA mới đủ tư cách xem xét để nâng lên phiên bản chính thức.
2.9.2 Mã nguồn ALPHA (thư mục src.alpha)
Một mã nguồn muốn vào được thư mục src, tức trở thành mã nguồn chính thức của GRASS, nó phải vượt qua được những yêu cầu khắc khe sau :
1. Chứng tỏ là hữu ít và cần thiết. Nghĩa là, nó không được viết ra chỉ nhằm để
thoả mãn cho một yêu cầu trong phạm vi của một khu vực, một tổ chức hay một ứng dụng nào đó.
2. Thoả mãn được các tiểu chuẩn về lập trình và tài liệu hướng dẫn do GRASS đề ra.
3. Có được sự chứng nhận là hữu dụng bởi ít nhất 3 nơi sử dụng độc lập.
4. Được đảm bảo sẽ có được sự hỗ trợ phát triển lâu dài.
Tóm lại, src.alpha sẽ là nơi chứa đựng những mã nguồn mới nhất, hay nhất và hấp dẫn nhất được cung cấp cho GRASS bởi cộng đồng mã nguồn mở.
2.9.3 Mã nguồn đóng góp (thư mục src.contrib)
Trang 96
Những mã nguồn loại này được thiết kế và cài đặt để thoả mãn cho một yêu cầu trong phạm vi của một tổ chức, khu vực hay một ứng dụng cụ thể nào đó.
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
2.9.4 Mã nguồn có liên quan (thư mục src.related)
Những mã nguồn này không được sự chứng nhận của OGI, nó thoã mãn cho một nhóm người dùng xác định nào đó.
2.9.5 Mã nguồn GARDEN (src.garden)
Tập hợp những phần mềm được phát triển để kết nối GRASS với những phần mềm khác có liên quan.
2.9.6 Các script (src/script/shell)
Chức các shell script dùng làm việc với GRASS. GRASS được phát triển trên UNIX và các script này là một cơ chế lập trình đơn giản nhưng đặc biệt quan trọng đối với GRASS.
2.10 Hướng dẫn cài đặt và sơ lược cách sử dụng
2.10.1 Cài đặt GRASS trên LINUX
GRASS5 có thể được tìm thấy ở dạng gói RPM của LINUX tại địa chỉ: http://ftp.gwdg.de/pub/misc/freegis/intevation/freegis/gnu-linux-i586/ để install gói này, ta dùng lệnh rpm của Linux :
rpm –i [ fileName ]
GRASS5 cũng có thể được download dạng binary dùng cho việc cài đặt tại website http://grass.itc.it/download.html ( bản binary này được biên dịch và nén theo dạng gzip tar của Linux, chỉ chạy được với Red Hat 7.0 trở lên) Để cài đặt bản binary này ta chỉ cần chạy script sh đi kèm trong phần download ( script sh là 1 dạng file giống file .bat trong Windows). Cụ thể script đi kèm để cài đặt có tên là grass5_i686-pc-linux- gnu_install.sh và gói binary có tên là grass5.0.0_linuxbin.tar.gz. Ta chỉ việc chạy script là xong ( nó sẽ tự động install vào vị trí default, nếu muốn lựa chọn chính xác thư mục để install, ta có thể customize script sh ) :
sh grass5_i686-pc-linux-gnu_install.sh grass5.0.0_linuxbin.tar.gz
Sau khi đã cài đặt thành công, ta khởi động GRASS bằng lệnh: Grass5 Để có được hướng dẫn trợ giúp, ta dùng lệnh Grass5 – help Để chạy GRASS5 với giao diện đồ hoạ TCLTK, ta dùng lệnh : tcltkgrass&
Trang 97
Để có thể sử dụng GRASS5, ta cần phải có thêm một thứ quan trọng khác là cơ sở dữ liệu. Trên website http://grass.itc.it/download.html có cung cấp 1 số dữ liệu mẫu như : leics.tar (dữ liệu vùng leceister ở nước Anh), global_grass5data.tar.. Ta chỉ việc giải
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
nén (gunzip) file dữ liệu vào một thư mục định sẳn, sau đó khai báo cho khi khởi động GRASS5 là xong.
Grass5 hỗ trợ 2 chế độ :
(cid:153) Chế độ Command line : Người sử dụng gõ lệnh trực tiếp để điều khiển. Lệnh được sử dụng là những lệnh của GRASS được xây dựng sẵn và được phân thành từng nhóm riêng biệt
g.* Nhóm các lệnh dùng cho việc quản lý file (general file manipulation command)
d.* Nhóm các lệnh dùng hiện thị (display on screen)
i.* Nhóm các lệnh xử lý hình ảnh (image processing)
r.* Nhóm các lệnh xử lý dữ liệu import là raster
v.* Nhóm các lệnh xử lý dữ liệu import là vector
s.* Nhóm các lệnh xử lý dữ liệu import là site (point)
Trang 98
(cid:153) Chế độ đồ hoạ : Hỗ trợ tương tác với GRASS-GIS bằng giao diện đồ hoạ. Dựa trên tập hợp lệnh đã có sẵn của GRASS, giao diện đồ hoạ được xây dựng bằng script TCL/TK khá đơn giản .
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Hình 2 - 7 Hình ảnh sử dụng GRASS5 trên Linux
2.10.2 Cài đặt GRASS trên Windows thông qua giả lập Cygwin
Grass5 có thể chạy được trên WindowsNT/2000/XP nhờ trình giả lập Cygwin, là một trình giả lập môi trường Linux/Unix, cho phép các ứng dụng của Unix/Linux có thể chạy được trên Windows. Có thể xem download miễn phí Cygwin tại www.cygwin.com
Grass5 phải được cài trên partition NTFS và Cygwin yêu cầu phải có XFree86 (giả lập XWindow của Linux/Unix). Bản GRASS5 giành cho Cygwin được download tại http://grass.itc.it/download.html .
Các bước cài đặt hoàn toàn giống với cài đặt trên Linux
• Cài đặt GRASS5 trên Cygwin
Các bước sử dụng GRASS tương tự trên môi trường Linux ( vì thật chất GRASS lúc này chạy được trên nền Cygwin giả lập Linux)
Trang 99
• Một số hình ảnh sử dụng GRASS5 trên nền Cygwin
Chương 2: Hệ thống hỗ trợ phân tích tài nguyên địa lý
Ta phải khởi động XServer trước khi khởi động Grass5 bằng lệnh ./startxwin.bat
Sau khi chạy XServer thành công, ta sẽ thấy chữ X ở taskbar và màn hình giao tiếp command với Cygwin trong chế độ XWindows. Lưu ý là do sự không tương thích, ta phải tắt các chương trình AntiVirus, Firewall … trước khi gọi lệnh khởi động XServer ( theo thông báo bug của Cygwin, thì ta phải uninstall các chương trình này ra khởi máy và ngay cả đối với việc install cũng không đảm bảo XServer sẽ hoạt động bình thường .. Khi thử nghiệm, chúng em phải gọi startxwin.bat vài lần thì XServer mới chịu hoạt động)
Gõ lệnh Grass5 để khởi động GRASS, xác lập cơ sở dữ liệu sẽ làm việc
Dùng các lệnh được cung cấp trong thư viện của GRASS để giao tiếp qua chế độ command line (gõ lệnh trực tiếp)
Hình 2 - 8 Hình ảnh sử dụng GRASS5 trên Windows thông qua giả lập Cygwin
Trang 100
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Chương 3 : Quá trình chuyển đổi GRASS5 từ Linux lên Windows
Chương 3 trình bày khái quát sự khác biệt giữa Windows và Linux, các khái niệm cần thiết
cùng với các kỹ thuật dùng để tái tổ chức phần mềm Grass từ hệ điều hành Linux sang hệ
điều hành Windows.
3.1 Sự khác biệt giữa Windows và Unix/Linux Phần này trình bày về những khác biệt cơ bản giữa môi trường UNIX và Windows.
3.1.1 Tổng quan về hệ điều hành Windows
Hình 3 - 0: Sơ đồ về sự phát triển của hệ điều hành windows
Trang 101
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Kiến trúc Windows NT có hai mức truy xuất hệ thống : User Mode và Kernel Mode
• User Mode : là một tập các hệ thống con được kiểm soát (protected subsystem)
của hệ điều hành và các tiến trình ứng dụng (mỗi ứng dụng khi chạy được xem là
một tiến trình). Các subsystem này cung cấp các giao tiếp với kernel của hệ thống
cho các ứng dụng trên Win, trong số đó subsystem quan trọng nhất là Win32
Subsystem cung cấp hầu hết các khả năng lập trình cho các ứng dụng trên nề
Windows 32 bit. Các ứng dụng lập trình trên Win thông qua các hàm API và các
hàm API đến lượt mình sẽ gọi các dịch vụ tương ứng được cung cấp từ các
subsystem bên dưới.
• Kernel mode : là một mức xử lý đặc biệt của hệ thống, bao gồm executive và
kernel. Kernel điều khiển hệ điều hành giao tiếp với bộ vi xử lý, thực hiện các tác
vụ hệ thống như : điều phối (sheduling), đồng bộ hóa đa tiến trình,và cung cấp
những dịch vụ cho phép executive có thể sử dụng và cung cấp ngược lại cho các
ứng dụng.
Executive cung cấp các dịch vụ cơ bản để các subsystem được kiểm soát có thể sử
Trang 102
dụng như : các tác vụ xử lý file, giao tiếp I/O và các tác vụ đồng bộ hóa.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Hình 3 - 1 Kiến trúc của hệ điều hành Windows theo họ NT
3.1.2 Tổng quan về hệ điều hành UNIX
Năm 1969, phòng thí nghiệm Bell phát triển hệ điều hành đa nhiệm UNIX, phiên bản
cài đặt đầu tiên được viết bằng ngôn ngữ assembly. Sau đó, cùng với việc sáng chế ra
ngôn ngữ C, BELL đã thiết kế và viết lại UNIX bằng ngôn ngữ này. UNIX từ đó trở
thành một hệ điều hành thông dụng do khả năng có thể chạy tốt trên nhiều lọai máy từ
máy tính cá nhân PC đến máy tính cỡ lớn như mainframe. Ngày nay, có rất nhiều dòng
hệ điều hành được phát triển trên nền UNIX, như :
• AIX của IBM
• Solaris của SUN Microsystem.
• HP-UX và Tru64 của Hewlett Packard
• UnixWare của Caldera
Trang 103
• Linux và FreeBSD, là hai hệ điều hành mã nguồn mở.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Hình 3 - 2 Các dòng hệ điều hành phát triển trên nền UNIX
Về kiến trúc, hệ điều hành UNIX có thể phân thành 3 lớp chức năng : mức thấp nhất là
kernel, cung cấp việc quản lý tài nguyên, các tác vụ điều phối, và vấn đề bảo mật
(security). Mức kế tiếp là shell, thông dịch các lệnh do người dùng đưa vào và khởi
Trang 104
động các ứng dụng. Mức cao nhất là utilities, cung cấp những ứng dụng hỗ trợ.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Hình 3 - 3 Kiến trúc của hệ điều hành UNIX
3.1.3 So sánh tổng quát về lập trình đa nhiệm trên hai môi trường
Đặc điểm Windows UNIX
Cơ chế chính, hỗ trợ mạnh Tiểu trình (thread) Tiến trình (process)
Hỗ trợ tiến trình Có Có
Hỗ trợ tiểu trình Có Có, nhưng cài đặt khác biệt
Tiểu trình Fiber Có Không
Điểm mạnh Hỗ trợ tốt việc tạo lập tiểu Hỗ trợ tốt đối với việc tạo
Trang 105
trình (thread) lập tiến trình (process)
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Cấu trúc phân cấp tiến trình Không Có
Kế thừa các “cờ” bảo mật Có Có ( trừ lệnh setuid)
của tiến trình cha
(cid:153) Vấn đề quản lý các tiến trình
Các hệ điều hành đa nhiệm như Windows và UNIX phải quản lý và điều khiển nhiều
tiến trình cùng một lúc. Mỗi tiến trình có dữ liệu, tài nguyên hệ thống, trạng thái … của
riêng nó. Tài nguyên bao gồm không gian bộ nhớ ảo, các tập tin và các đối tượng điều
phối. Các tiểu trình là một phần của một tiến trình, mỗi tiến trình có thể có một hoặc
nhiều hơn một tiểu trình chạy bên trong nó. Giống tiến trình, một tiểu trình cũng có tài
nguyên và trạng thái của riêng nó. Hệ điều hành Windows và UNIX đều hỗ trợ tiến
trình và tiểu trình nhưng có cách quản lý khác nhau.
(cid:153) Vấn đề đa nhiệm
UNIX được thiết kế với chiến thuật điều phối độc quyền truy xuất (preemptive
multitasking) thích hợp cho người dùng tạo ra nhiều tiến trình chạy đồng thời tại một
thời điểm. Do đó, lập trình viên trên UNIX thường tạo ra một tiến trình mới mỗi khi
cần tạo các xử lý đồng thời trong ứng dụng.
Việc tạo lập một tiến trình mới trên Windows, ngược với UNIX, tiêu tốn rất nhiều tài
nguyên và bản thân chiến thuật điều phối của Windows không thích hợp nên lập trình
viên trên Windows thường tạo lập các tiểu trình (thread) mỗi khi cần xử lý đồng thời.
Trang 106
Windows cũng có một lọai thread đặc biệt là Fiber mà UNIX không có, đây được gọi
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
là thread “nhẹ” (lightweight thread) , thích hợp cho các ứng dụng phải phục vụ một số
lớn người dùng như hệ thống cơ sở dữ liệu ..
Đây là khác biệt quan trọng giữa Windows và các hệ điều hành phát triển trên nền
UNIX.
(cid:153) Cấu trúc phân cấp của tiến trình
Khi một ứng dụng UNIX tạo lập một tiến trình (process), tiến trình mới trở thành tiến
trình con của tiến trình tạo lập. Cấu trúc phân cấp này thường quan trọng và hệ thống
sẽ có những chỉ thị lệnh để quản lý các tiến trình con này.
Tiến trình trong Windows không hoàn toàn sử dụng cấu trúc phân cấp như UNIX. Khi
tạo lập tiến trình, ta nhận được handle và cả ID của tiến trình, việc tạo lập cấu trúc
phân cấp như UNIX là tùy chọn đối với ứng dụng nếu nó thật sự cần.
(cid:153) Vấn đề signals, exceptions, và events
UNIX và Windows đều có cơ chế giúp tiến trình xử lý một sự kiện hay một lỗi xảy ra.
Trong UNIX cơ chế này gọi là signal, trong Windows thì có cơ chế exception trong đó
Windows sử dụng Cấu trúc Xử lý ngoại lệ (Structured Exception Handling – SEH) để
xử lý.
(cid:153) Vấn đề bộ lọc (filter) và ống dẫn (pipes)
UNIX giới thiệu một kiến trúc khác biệt trong lập trình là : bộ lọc và ống dẫn. Một
chương trình trong UNIX có thể xem như một “bộ lọc nước”, nó nhận dữ liệu vào từ
một “dòng nhập liệu chuẩn” (input stream) và sau khi xử lý nó sẽ cho dữ liệu “chảy” ra
Trang 107
một “dòng kết quả chuẩn” (output stream). Ống dẫn cho phép ta nối các bộ lọc nước
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
này lại với nhau, nghĩa là “dòng kết quả” của bộ lọc này lại tiếp tục được “lọc” qua
một bộ lọc nước khác trước khi ra ngoài, hay sẽ có nhiều “bộ lọc” nối tiếp nhau trong
việc xử lý dữ liệu đầu vào.. Đây là điểm đặc biệt của UNIX mà Windows không có.
(cid:153)Tiến trình Daemons và Windows Services
Trong UNIX, một tiến trình deamon là tiến trình được hệ thống khởi động để cung cấp
một dịch vụ nào đó cho những ứng dụng khác. Thông thường, tiến trình deamon không
giao tiếp với người sử dụng. UNIX sẽ khởi động tiến trình deamon lúc boot máy trong
đoạn script khởi tạo.
Khái niệm tiến trình deamon trong UNIX tương đương với khái niệm Windows
Services trong Windows. Các services hoàn toàn giống deamon về vai trò nhiệm vụ và
cũng được khởi động ở giai đoạn boot máy, các service được điều khiển thông qua Bộ
điều khiển Service ( Service Control Manager – SCM), ta phải giao tiếp khi lập trình
với SCM để quyết định việc khởi tạo, dừng và cài đặt cho Service.
(cid:153) Vấn đề giao tiếp giữa các tiến trình
Các hệ điều hành đa nhiệm phải cung cấp cơ chế cho phép các ứng dụng (tiến trình)
giao tiếp và chia sẻ dữ liệu với nhau. Cơ chế này gọi là giao tiếp liên tiến trình
(Interprocess Communication – IPC)
Đối với UNIX : Bộ nhớ được chia sẻ, pipe, và hàng đợi message (message queue)
Đối với Windows : bên cạnh Bộ nhớ được chia sẻ, pipe, và hàng đợi message
Trang 108
(message queue) nó còn có thêm clipboard, COM, DDE, và cơ chế send message.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
(cid:153) Đồng bộ hoá
Cả UNIX và Windows đều có cơ chế đồng bộ hoá thông qua semaphores, mutex và
miền găng (critical section).
Semaphore để kiểm soát sự truy cập vào tài nguyên đòi hỏi phải giới hạn số lượng user
truy cập xác định.
Mutex dùng để tạo cơ chế độc quyền truy xuất, chỉ cho một user được sử dụng tài
nguyên tại một thời điểm.
Miền găng là một phiên bản thu nhỏ của mutex, chỉ thực hiện điều phối trong phạm vi
một tiến trình, giữa các tiểu trình (thread) tranh chấp tài nguyên của tiến trình với nhau.
Tại một thời điểm, chỉ cho một tiểu trình sử dụng tài nguyên của tiến trình.
3.1.4 So sánh về hệ thống file của hai môi trường
Đặc điểm Windows UNIX
Phân cấp và đa cây Phân cấp và đơn cây Cấu trúc tổng quát
Có (C,D) Không, mọi thứ được Có phân biệt ổ đĩa và thư mục
mount vào cây quản lý.
\ / Ký tự phân cách đường dẫn
Có Phân biệt chữ hoa và chữ thường Không
Trang 109
SMB NFS Hệ thống file mạng
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Không Có Tập tin thiết bị
Không Có Thiết lập ID của User quản lý
cho tập tin/ thư mục
ACLs Simple bit permissions Security
(cid:153) Tập tin thiết bị (device file) : trong UNIX, thiết bị phần cứng được đại diện bằng
những tập tin, thường chứa trong thư mục /dev. Nhờ đặc điểm này, ta có thể chạy một
chương trình nhưng hông thèm nhận kết quả trả về của nó bằng cách chuyển hướng kết
quả (redirect - tức dùng ký tự ‘>’ hoặc ‘<’ ) kết xuất của chương trình ra null device,
/dev/null. Dùng kỹ thuật tương tự, ta có thể gửi dữ liệu trực tiếp ra cổng song song
(serial port) ..
(cid:153) Hệ thống file mạng (Network File System)
Đối với UNIX, đó là Network File System – NFS, phát triển bởi Sun
Microsystems.Tóm gọn cơ chế như sau : NFS server sẽ cung cấp một thư mục cho
phép chia sẻ, và NFS client có quyền mount thư mục đó vào cây thư mục của mình.
Trên nền MS-DOS, việc chia sẻ tài nguyên được thực hiện thông qua NetBIOS
(Network Basic Input Output System), tự động chuyển đến thư mục/tập tin trên máy
tính khác khi yêu cầu I/O đến những thư mục/ tập tin này được chấp thuận. NetBIOS
sử dụng giao thức Server Message Block (SMB), ngày nay giao thức này được phát
triển thêm để có thể ứng dụng trên Internet và được gọi tên mới là Common Internet
Trang 110
File System (CIFS).
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
(cid:153) Mô hình bảo mật của UNIX
UNIX gán quyền hạn truy cập của user trực tiếp lên file. Mô hình này làm việc tốt vì
UNIX sử dụng file để đại diện cho thiết bị, bộ nhớ và ngay cả tiến trình. User có thể là
người dùng đã đang nhập thành công vào hệ thống hoặc có thể là một service của hệ
thống. Mỗi USER thuộc về một GROUP và có một UID (User ID). Mỗi GROUP có
nhiều USER và có một GID (Group ID). Mỗi tiến trình đều thuộc về một UID và một
GID xác định.
(cid:153) Mô hình bảo mật của Windows
Trong mô hình trên
user : Người dùng đăng nhập thành công vào hệ thống.
objects : là những tài nguyên yêu cầu bảo mật của hệ thống. Ví dụ như tập tin, các
đối tượng đồng bộ hoá, các đối tượng kernel ...
Access Token : là một cấu trúc dữ liệu đi kèm với mỗi tiến trình , xác định người
dùng khởi động tiến trình này là ai, thuộc nhóm security nào. Mỗi Access Token
Trang 111
được định danh trong hệ thống thông qua một SID (Security Identifiers)
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Security Descriptor : thông tin mô tả thuộc tính bảo mật của mỗi tài nguyên.
Thông tin này bao gồm người chủ (owner) của object này là ai, và một danh sách
các quyền hạn cho phép truy cập DACL (Discretionary Access Control List ).
Danh sách này có thể bao gồm nhiều quyền, mỗi quyền được được gọi là một đơn
vị quyền hạn truy cập ACE ( Access Control Entry), trong ACE sẽ chứa danh sách
các SID được phép đối với quyền này.
Mô tả :
Khi một tiến trình truy xuất vào một tài nguyên có yêu cầu bảo mật, hệ thống sẽ
kiểm tra trong danh sách DACL của tài nguyên đó, cụ thể là ở mỗi ACE xem có SID
của tiến trình này có được phép không. Kết thúc quá trình này, hệ thống sẽ xác định
được những quyền hạn mà tiến trình được phép thực hiện đối với tài nguyên này và
dựa vào đó quyết định từ chối hay chấp nhận yêu cầu của tiến trình.
3.1.5 Giao diện người dùng
UNIX dựa trên giao tiếp lệnh là chính, người dùng gõ lệnh trực tiếp trong khi đó
Windows sử dụng hoàn toàn giao tiếp đồ hoạ (dù rằng vẫn hỗ trợ giao tiếp lệnh một
cách hạn chế). Lý do là khi UNIX được xây dựng, khả năng đồ hoạ của máy tính còn
rất hạn chế, đến giai đoạn Windows ra đời thì điều này đã được cải thiện.
Để cung cấp khả năng giao tiếp thông qua giao diện đồ hoạ tương tự Window cho
Trang 112
UNIX, một hệ thống hỗ trợ được gọi là XWindows, được phát triển bởi đại học MIT.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
3.1.6 Shell và script
Shell là một công cụ thông dịch các lệnh được nhập vào bởi người dùng và sau đó
“chạy” và thể hiện kết quả của các lệnh đó. Ngoài việc chạy các chương trình ra, shell
còn hỗ trợ thêm các đặc điểm cao cấp khác như cho phép gọi lại những lệnh đã được
thực hiện gần đó, và cung cấp một ngôn ngữ lập trình dạng script để có thể viết những
chương trình đơn giản.
Trên nền Windows, lệnh cmd.exe sẽ mở shell của Windows cho phép chạy các
command. Trên nền Windows, các script có thể kể đến là VBScript, JScript chạy được
nhờ Windows Script Host (WSH).
Trên nền UNIX : có nhiều kiểu shell
• Bourne Shell (sh) là shell đơn giản nhất và là shell mặc định, có thể gọi một
chương trình, tạo pipe nhưng không có bộ nhớ lệnh.
• C Shell (Csh) : có bộ nhớ lệnh và ngôn ngữ script tương tự như ngôn ngữ lập trình
C
• Korn Shell (Ksh) : có bộ nhớ lệnh và khả năng xây dựng script. Được phát triển
lên từ Bourne Shell.
UNIX giao tiếp với người dùng phần lớn thông qua gõ lệnh trực tiếp, nên các shell đóng vai
trò quan trọng. Bên cạnh các shell, một loại ngôn ngữ lập trình đơn giản khác cũng được hỗ
trợ là script : Python, Perl, TCL/TK ..
3.2 Sơ lược về phần mềm GRASS Phiên bản GRASS mới nhất (tính đến thời điểm 8/7/2004) là version 5.7
Trang 113
Phiên bản GRASS mà chúng em đang chuyển đổi vào thời điểm nhận luận văn là 5.0.2
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Source Grass5 (phiên bản các loại) có thể download tại http://grass.itc.it/download.html
Source được nén theo kiểu .tar, có tên như sau: grass5.0.2_src.tar
Chú ý:
Source Grass có 2 phiên bản, phiên bản chạy trên Linux và phiên bản chạy trên CygWin (là
một trình giả lập môi trường Linux chạy trên Windows)
3.3 Sơ lược về mã nguồn của GRASS 5.0.2 Kích thước tổng cộng của Source Grass trên xấp xỉ gần 100 MB, số lượng file tổng cộng là
19777 files, nằm trong 2860 folder.
Trong đó, thư mục SRC là thư mục phát triển chính yếu, thư mục này chứa toàn bộ source
code cần thiết tối thiểu nhất để chạy chương trình. Các thư mục còn lại chỉ là các package
kèm theo, các tools, các tài liệu, cùng với các source phát triển khác còn dang dở như:
src.contrib, src.garden, src.todo v.v…
Source Grass được viết bằng ngôn ngữ C trên Linux (tạm gọi là C-Linux), là ngôn ngữ
giống với ANSI C trên Window, nhưng có sử dụng nhiều thư viện hệ thống khác mà trên
Window không có, ví dụ như thư viện #include
Bên cạnh đó, hệ thống xử lý đồ họa trong Linux cũng hoàn toàn khác với MS Window, C-
Linux sử dụng hệ thống đồ họa là các hàm X, để tương tác với hệ thống giao diện đồ họa
XWindow của Linux.
(Ghi chú thêm: Bộ thư viện lập trình đồ họa trên Linux (giống như bộ thư viện GDI của
Windows) bao gồm 3 thư viện là: XLIB, XTOOLKIT, và MOTIF, trong đó GRASS sử dụng
Trang 114
bộ thư viện cơ bản nhất là XLIB, sẽ được xem xét kỹ hơn vào phần sau )
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Ngoài source code C/Linux ra, source Grass còn được viết bằng các tập tin Shell Script
(*.sh – là một tập tin thực thi giống như file .bat trên Window), các Script này sẽ được gọi
để hỗ trợ cho source C…
3.4 Môi trường sử dụng để chuyển đổi GRASS5
Chúng em sử dụng môi trường chuyển đổi là VISUAL® C++ 6.0 Service Pack 5
Phương châm chuyển đổi:
+ Để tiết kiệm thời gian và công sức, chúng em đề ra phương châm là:
“…Hạn chế sửa đổi mã nguồn của GRASS đến mức thấp nhất”
Một số điều kiện cần thiết:
+ Do Source Grass được viết theo kiểu lập trình hướng thủ tục cổ điển
(procedure oriented programming), không sử dụng lập trình hướng đối tượng, nhưng vẫn sử
dụng cơ chế include prototype (có nghĩa là sẽ có 2 file, 1 file .h chứa các hàm prototype, 1
file .c sẽ chứa các cài đặt của các hàm mô tả trong file .h đó, chẳng hạn, ...) nên khi sử dụng
kiểu include như vậy trên Visual C++ thì phải chỉnh lại Setting như sau:
Bấm tổ hợp Alt+F7 để vào Setting −
Chọn tab C/C++ −
Chọn Category là PreCompiled Headers −
Chọn option “Automatic use of precompiled headers” −
Nếu không thiết lập như trên thì khi add vào 1 file .h, 1 file .c thì VC++ sẽ không hiểu và sẽ
Trang 115
báo lỗi “Unexpected end of file ….”
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
+ Do Source Grass được viết bằng C, mà trình biên dịch VC++ lại dịch theo kiểu C++, (có
nghĩa là file .cpp gọi hàm trong file .c sẽ không được), nên chúng ta phải sử dụng một số chỉ
thị tiền xử lý (pre-compiler directive) để định hướng lại biên dịch khi gọi hàm ANSI C như
// đoạn code bằng C++ #ifdef __cplusplus extern "C" { #endif //.................. // đoạn code bằng C //.................. #ifdef __cplusplus
sau:
}
#endif // đoạn code bằng C++
3.5 Các vấn đề chính khi chuyển đổi lên Windows
3.5.1 Khởi tạo các biến môi trường cần thiết
Grass khi chạy cần phải được thiết lập một số biến môi trường mới có thể thực hiện,
các biến này được set trong các script init.sh .
Trong VC++, chúng ta sẽ khởi tạo các biến môi trường bằng hàm:
_putenv(“tênbiến=giátrị”)
Ví dụ:
// tạo và gán biến môi trường GISDBASE là “c:\grassdata”
_putenv(“GISDBASE=c:\\grassdata\\”);
( Hoặc chúng ta có thể tạo biến môi trường trực tiếp ngoài Window bằng cách chọn
Trang 116
Property của MyComputer (cid:206) tab Advanced (cid:206) EnviromentVariable (cid:206) New)
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
- Danh sách các biến môi trường mà GRASS sử dụng:
Tên Biến Ý Nghĩa
Đường dẫn tuyệt đối đến thư mục cài đặt GISBASE
project GRASS .
(Ví dụ: c:\projects\grassProject )
Đường dẫn đến thư mục chứa database của GISDBASE
GRASS. (Ví dụ: c:\grassdata )
Đường dẫn đến thư mục dữ liệu làm việc của LOCATION_NAME
GRASS. (Ví dụ: c:\grassdata\spearfish )
Đường dẫn đến thư mục mapset mà GRASS sẽ MAPSET
làm việc.
(Ví dụ: c:\grassdata\spearfish\permanent )
Monitor đang được chọn để hiển thị hiện tại MONITOR
Chỉ đến thư mục lưu trữ file .grassrc5, là file GISRC
chứa thông tin về tất cả các biến môi trường.
Khi được khởi động, GRASS sẽ đọc từ file
.grassrc5 để khởi tạo các biến môi trường
khác được lưu trong đó.
Biến này ghi nhận đường dẫn đến file GIS_LOCK
gis_lock, là file GRASS dùng để đảm bảo cơ
Trang 117
chế lock (khoá) của chương trình (chỉ chạy
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
một instance duy nhất ).
Thiết bị hiển thị đang được chọn. PAINTER
digitizer đang được chọn. DIGITIZER
Chiều rộng hiện tại của cửa số XWindow GRASS_WIDTH
(Monitor) đang được chọn .
Chiều cao hiện tại của cửa sổ Xwindow GRASS_HEIGHT
(Monitor) đang được chọn.
Lưu ID của Window (monitor) đang hiển thị. XDRIVER_WINDOW
Xác định Xdriver có sử dụng chế độ true color XDRIVER_TRUECOLOR
hay không
…… XDRIVER_PRIVATE_CMAP
…….
Sau này khi muốn lấy lại giá trị của một biến môi trường nào đó, ta chỉ cần gọi hàm:
getenv(“Tênbiến”)
Ví dụ:
char *gisbaseName = getenv(“GISBASE”);
Ngoài cách sử dụng _putenv, getenv các biến môi trường theo cách trên, GRASS còn xây
dựng riêng cho mình một hệ thống biến môi trường để sử dụng riêng, các biến này được lưu
trong file .grassrc5. Grass sẽ sử dụng một mảng 2 chiều (dạng bảng) để lưu trong bộ nhớ
Trang 118
các biến môi trường cục bộ của nó, các biến này được truy xuất bằng các hàm gis sau:
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
G__getenv(“TênBiến”) Lấy giá trị của biến môi trường trong
bảng môi trường riêng của nó (trong
bộ nhớ).
Cụ thể là hàm này sẽ search trong
bảng môi trường, lấy ra giá trị của
tên biến truyền vào tương ứng.
G__setenv(“TênBiến”, “Giá Trị”) Hàm này thiết lập lại giá trị của biến
môi trường trong bảng môi trường.
BẢNG MÔI TRƯỜNG
Biến Giá Trị
Biến1 Giá Trị 1
Biến 2 Giá Trị 2
…… ……
3.5.2 Dữ Liệu GRASS và Cấu trúc của dữ liệu GRASS
(cid:153) Grass Database :
Grass khi chạy cần phải có cơ sở dữ liệu database tạo sẵn, các database này được tạo riêng,
Trang 119
(chúng ta chưa cần quan tâm đến cách tạo như thế nào), và dựa vào dữ liệu đó, Grass mới
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
thực hiện các thao tác hiển thị, phân tích, truy vấn để trả kết quả về cho người sử dụng (cũng
(cid:153) Cấu trúc của Grass Database :
như lập trình viên)...
Database của Grass được chứa trong một thư mục (gọi là GISDBASE)
GISDBASE có thể chứa nhiều database khác nhau.
Ví dụ: GISDBASE = C:\GRASSDATA\
Giả sử có chứa các database:
(cid:198) Spearfish: C:\GRASSDATA\SPEARFISH\
(cid:198) Slovakia: C:\GRASSDATA\SLOVAKIA\
(cid:198) Global: C:\GRASSDATA\GLOBAL\
Mỗi database còn được gọi là một LOCATION
Ví dụ, với cấu trúc trên thì thư mục Spearfish là một Location, thư mục Slovakia là một
Location, v.v…
Trong Location có nhiều một hoặc nhiều thư mục khác nhau, mỗi thư mục đó là một
MAPSET.
Ví dụ, trong thư mục C:\GRASSDATA\SPEARFISH\ có thư mục PERMANENT thì có
nghĩa là database SPEARFISH có 1 MAPSET tên là PERMANENT.
Các Element của Mapset: (có 8 map layer, dùng để liệt kê trong hàm g.list)
1) Raster Files
- Files dạng Raster, được chứa trong thư mục CELL. Nếu không tồn tại thư mục này hoặc
Trang 120
thư mục không có file nào thì có nghĩa là Mapset không có Raster files nào.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
2) Binary Vector Files
- Files dạng Vector, được chứa trong thư mục DIG. Nếu không tồn tại thư mục này hoặc
thư mục không có file nào thì có nghĩa là Mapset không có Binary Vector Files nào.
3) Paint Icon Files
4) Paint Label Files
- Các files dạng Paint Label, được chứa trong thư mục PAINT/LABEL. Nếu không tồn tại
thư mục này hoặc thư mục không có file nào thì có nghĩa là Mapset không có Paint Lable
Files nào.
5) Site List Files
- Files dạng SITE, được chứa trong thư mục SITE_LISTS. Nếu không tồn tại thư mục này
hoặc thư mục không có file nào thì có nghĩa là Mapset không có Site List Files nào.
6) Region Definition Files
- Files dạng REGION, được chứa trong thư mục WINDOWS. Nếu không tồn tại thư mục
này hoặc thư mục không có file nào thì có nghĩa là Mapset không có Region Definition
Files nào.
7) Imagery Group Files
8) 3D View Parameters
3.5.3 Cấu trúc chung của source code GRASS
Thư mục SRC là thư mục code chính của Grass5.0.2. Trong thư mục này, sẽ có các thư
mục con chứa cài đặt của GRASS, sau đây là một số diễn giải về cấu trúc mã nguồn của
Trang 121
GRASS được phân cấp từ thấp đến cao:
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
3.5.3.1 Cài đặt bộ thư viện trung tâm
Thư Mục SRC\ LIBES
i) Cấu trúc
- Grass đã xây dựng một bộ thư viện nền để làm nền tảng cơ sở cho việc phát triển tiếp sau
này, có thể nói đây là phần cốt lõi (kernel) của GRASS, bộ thư viện này nằm trong thư mục:
SRC\LIBES\
- Bộ thư viện này bao gồm tập hợp các thư viện chính sau:
Tên Thư Viện Ý Nghĩa
SRC\LIBES\GIS\ GIS LIB: Thư viện trung tâm xử lý GIS. Module
này bao gồm các hàm phân tích, tính toán cần thiết
của GIS.
Các hàm thuộc thư viện này thường có tiếp đầu
ngữ là G_xxx
Ví dụ: G_GisInit(…), G_Parser(..)
SRC\LIBES\DISPLAY\ DISPLAY LIB: Thư viện các hàm xử lý tương tác
với driver đồ hoạ (XWindow).
Các hàm trong Display thường có tiền tố là D_xxx
Ví dụ: D_new_window(…), D_clear(…)
SRC\LIBES\RASTER\ RASTER LIB: Thư viện các hàm xử lý tương tác
với driver đồ hoạ (XWindow). Giống với thư viện
Trang 122
Display, nhưng ở mức thấp hơn. (được các hàm
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
của Display gọi lại )
Các hàm trong Raster thường có tiền tố là R_xxx
Ví dụ: R_Pad_Create(…), R_Polygon_rel(...)
SRC\LIBES\BITMAP\ Thư viện chứa các xử lý Bitmap
SRC\LIBES\BTREE\ Thư viện chứa các xử lý trên cây nhị phân
SRC\LIBES\D\ Thư viện chứa các hàm Display mở rộng
SRC\LIBES\DATETIME\ Thư viện ngày giờ …
SRC\LIBES\DBMI\ Bộ thư viện dùng cho việc kết nối và xử lý trên
Database
SRC\LIBES\DIG_ATTS\ Bộ thư viện dùng để đọc và ghi vào file có dạng
thuộc tính (attribute files format)
SRC\LIBES\DIGITIZER\ …
SRC\LIBES\G3D\ Thư viện chứa các xử lý Graphics 3D
SRC\LIBES\GMATH\ Thư viện chứa các hàm tính toán “toán học”.
SRC\LIBES\IBTREE\ Bộ thư viện về khác về BTREE
Trang 123
…….. …còn nhiều nữa.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Chú ý là các bộ thư viện trên đan xen lẫn nhau, thư viện này gọi thư viện khác để cài đặt,
người sử dụng không nên quan tâm đến cài đặt bên trong mà chỉ quan tâm đến các hàm mô
tả trong file .h
- Sử dụng bộ thư viện LIBES bằng cách #include các file .h trong thư mục
SRC\INCLUDE\
Ví dụ:
Để sử dụng các hàm do GIS cung cấp (thư viện GIS LIB), ta chỉ cần khai báo #include
“gis.h”
Để sử dụng các hàm vẽ được cung cấp bởi thư viện DISPLAY LIB, ta khai báo #include
“display.h”
ii) Các vấn đề khi convert libes
- Đây là bộ thư viện trung tâm chỉ để dùng trong xử lý, tính toán, phân tích, thuật toán, nên
việc convert phải được thực hiện chính xác. Các vấn đề ở đây là khi convert, chúng ta gặp
phải một số thư viện không tồn tại trên Win32, chẳng hạn như unistd.h, pwd.h, …. , đối với
các thư viện này thì chúng em có thể tìm hiểu ý nghĩa của chúng để thay thế lại bởi các hàm
trong thư viện này bởi các hàm tương ứng bên Windows. Duy đặc biệt có 2 thư viện là
ZLIB (
ứng bên Window để thay thế, vì thế, chúng em phải bỏ công sức để tìm kiếm source code
cho 2 bộ thư viện trên, và một dự án open source đang phát triển trên Net khác đã giúp
chúng em đạt được kết quả.
3.5.3.2 Cài đặt các nhóm lệnh xử lý của Grass
Trang 124
1) Nhóm lệnh D.*
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Được cài đặt trong thư mục SRC\DISPLAY
Bằng cách sử dụng lại các hàm thư viện được cung cấp trong LIBES, các lệnh
thuộc nhóm Display sau được cài đặt :
a. Lệnh d.mon
Lệnh này có các tham số: start, stop, select, status, release, list, which
Ví dụ: d.mon start=x0 sẽ khởi tạo cửa sổ đồ họa monitor x0
d.mon select=x0 sẽ chọn cửa sổ x0 là cửa sổ mặc định
i) Cấu trúc
o Nằm trong thư mục SRC \ DISPLAY \ D.MON \
o Khi gọi thực hiện lệnh này thì hàm main() trong thư mục D.MON \ CMD \
sẽ được thực hiện đầu tiên, nó phân tích cú pháp của chuỗi lệnh được nhập
vào, rồi dựa vào tham số được phân tích ra để quyết định gọi thực hiện
module nào trong thư mục D.MON \ PGMS \
o Thư mục D.MON \ PGMS \ sẽ cài đặt các module khác nhau của ham d.mon
và các module này sẽ được dịch độc lập ra đối tượng riêng lẻ .obj , để sau
này các hàm khác gọi thực hiện chúng (trong Linux)
Ví dụ:
- Lệnh d.mon start=x0 sẽ được cài đặt trong file PGMS\start.c
- Lệnh d.mon stop=x0 sẽ được cài đặt trong file PGMS\stop.c
....
Trang 125
Ghi chú:
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
(cid:198) Hàm d.mon start là các hàm rất đặc biệt, nó thực hiện mở một cửa số monitor
bằng cách mở XDRIVER, là một giao thức (protocol) để giao tiếp với
XWindow của Linux. Cách thức chạy của nó dựa vào cơ chế SendMessage riêng,
sẽ được trình bày trong phần sau.
Còn thư mục D.MON \ INTER \ chỉ để cài đặt giao diện trực quan (Visual) dùng để tương
tác với người dùng, nó cũng phải gọi lại các module được cài đặt trong thư mục PGMS
trên.
ii) Cách thức chuyển đổi d.mon
- Do đây không phải là thư viện, và cách thức biên dịch cũng khác với Win32
(gọi thực hiện một command obj bên ngoài), nên cách chuyển đổi của chúng em ở
đây là đọc hiểu cơ chế thực hiện của chương trình, mô hình hóa cơ chế đó, sau đó
viết lại hoàn toàn cơ chế đó trên Win32
- Mô tả sơ bộ cách thức hoạt động của hàm d.mon start :
Khi hàm d.mon start=xi được gọi (xi = x0, x1, x2, …, là danh sách các monitorname
nằm t trong file monitorcap – xem phần sau), chương trình sẽ làm các công đoạn sau:
• Tự động gọi thực hiện module d.mon select=xi
• Cập nhật biến môi trường MONITOR=xi .
• Khởi tạo cửa sổ Driver XWindow “xi”
• Duyệt trong file monitorcap để mở ra 2 file fifo tương ứng. (thường là : dev/fifo.ia,
dev/fifo.ib )
• Gọi chạy một process song song để kiểm tra file input là fifo.ia liên tục, xem coi có
Trang 126
EVENT nào được gửi tới cho MONITOR xi hay không? Nếu có thì thực hiện hành
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
động đáp ứng tương ứng với EVENT nhận được. (Cụ thể là nếu EVENT gọi vẽ ra
màn hình XWindow “xi” thì dùng các hàm X để vẽ, còn nếu EVENT yêu cầu trả về
một kết quả tính toán thì sẽ tính toán để trả kết quả về bằng cách ghi kết quả vào
file fifo.ib ).
(cid:206) Cơ chế này sẽ được trình bày chi tiết hơn ở phần sau: Cơ chế SendMessage trong
GRASS
- Mô tả sơ bộ cách thức hoạt động của hàm d.mon select :
Khi hàm d.mon select=xi được gọi (xi = x0, x1, x2, ….), chương trình sẽ thực hiện các
công đoạn sau:
• Kiểm tra xem cửa sổ MONITOR xi có đang được chọn
• Nếu không thì chọn (select) cửa sổ đó (lấy cửa sổ đó là cửa sổ hiện hành )
- Mô tả sơ bộ cách thức hoạt động của hàm d.mon stop:
Khi hàm d.mon stop=xi được gọi (xi = x0, x1, x2, ….), chương trình sẽ thực hiện các
công đoạn sau:
tra EVENT lại bằng cách gửi EVENT có tên là • Đóng Process kiểm
“GRAPH_CLOSE” tới MONTOR xi, Process Check Event khi bắt được EVENT
này thì sẽ tự động End Process lại ..
• Đóng 2 file kết nối fifo.ia, fifo.ib lại
Trang 127
• Đóng cửa sổ MONITOR xi đang mở lại (XDestroyWindow(..))
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
b. Lệnh d.rast
Lệnh này sử dụng để hiển thị thông tin của raster chỉ định lên màn hình MONITOR
Graphics Windows.
Ví dụ: Lệnh: d.rast aspect
sẽ hiển thị lên màn hình xi hiện tại thông tin của raster “aspect”.
i) Cấu trúc
Nằm trong thư mục SRC\ DISPLAY\ D.RAST\ •
Khi gọi thực hiện lệnh này thì hàm main() trong thư mục D.RAST \ CMD \ •
sẽ được thực hiện đầu tiên, nó phân tích cú pháp của chuỗi lệnh được nhập
vào, rồi dựa vào tham số được phân tích ra để xác định tên của Raster cần
hiển thị.
ii) Cách thức chuyển đổi
- Do đây cũng không phải là thư viện, và cách thức biên dịch cũng khác với Win32 (gọi thực
hiện một command obj bên ngoài), nên cách chuyển đổi của chúng em ở đây là đọc hiểu cơ
chế thực hiện của chương trình, mô hình hóa cơ chế đó, sau đó viết lại hoàn toàn cơ chế đó
trên Win32
- Mô tả sơ bộ cách thức hoạt động của hàm d.rast :
Khi hàm d.rast “raster_name” được gọi, chương trình sẽ thực hiện các công đoạn cơ bản
sau:
Trang 128
• Phân tích cú pháp để lấy ra “raster_name”
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
• Kiểm tra xem “raster_name” yêu cầu có tồn tại không trong Location hay không?
• Nếu có thì nó sẽ đọc biến môi trường MONITOR hiện hành ra, mở 2 file fifo.ia,
fifo.ib tương ứng với monitor.
• Yêu cầu vẽ ra window MONITOR bằng cách gửi EVENT vào file fifo.ia, nếu
EVENT có yêu cầu kết quả trả về thì sẽ nhận kết quả trả về trong file fifo.ib (đọc
file fifo.ib )
… …
3.5.3.3 Các Driver dùng để hiển thị của Display
- Các Driver là các trình dùng để điều khiển cách thức hiển thị kết quả tính toán (kết xuất
ra màn hình, máy in, files các loại, chẳng hạn….). Tùy theo loại MONITOR mà người dùng
khởi tạo mà Grass sử dụng Driver tương ứng. (dựa vào cấu trúc MON trong file
DISPLAY\DEVICE\MONITORCAP\monitorcap )
- Cấu trúc file monitorcap:
File monitorcap là file ghi danh sách các biến MONITOR mà grass sử dụng (ví dụ: x0,
x1,…), mỗi monitor name đều có một Driver, một cặp file ghi biến cố, và nhiều trường
(field) khác v.v…tương ứng. (mỗi trường cách nhau bởi dấu hai chấm ‘:’ )
Ví dụ:
Xét 1 dòng trong file monitorcap:
x0:driver/XDRIVER:X-windows graphics display: \
dev/fifo.1a dev/fifo.1b \
Trang 129
::any terminal
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
(cid:198) Dòng trên có nghĩa là Grass có hỗ trợ một monitor tên là x0, monitor này sử dụng driver
là XDriver, mô tả driver Xdriver là X-windows graphics display, và monitor này có 2 file
xử lý ghi nhận Event là fifo.1a và fifo.1b (trong thư mục “dev”), v.v…
Ý nghĩa các trường (field) trong cấu trúc file Monitorcap:.
STT Mô Tả
1 Monitor name
2 Driver tương ứng
3 Mô tả về Driver đó
4 Tên của 2 file fifo dùng để giao tiếp các
event …
5 Tên đầy đủ của terminal tty mà device
được khởi tạo
6 Thông báo mà người dùng sẽ nhận được
nếu driver được bắt đầu từ một tty không
đúng.
- Grass5 hỗ trợ các Driver sau đây:
Tên Driver Mô Tả
Trang 130
Driver này dùng để điều khiển kết quả XDRIVER
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
xuất ra màn hình XWindow
Xuất ra file dạng CELL CELL
Xuất ra file dạng Webpage HTML HTMLMAP
Xuất ra dạng file ảnh PNG PNGDRIVER
- Danh sách các cửa sổ MONITOR mà Grass5.0.2 hỗ trợ:
Dựa vào file monitorcap, Grass cung cấp một danh sách các monitor mà nó hỗ trợ cùng
với các thuộc tính đi kèm của monitor (xem trong file monitorcap)
Tên Driver File FiFo giao tiếp
(trong thư mục Dev)
x0 XDRIVER fifo.1a (cid:197)(cid:198) fifo.1b
x1 XDRIVER fifo.2a (cid:197)(cid:198) fifo.2b
x2 XDRIVER fifo.3a (cid:197)(cid:198) fifo.3b
x3 XDRIVER fifo.4a (cid:197)(cid:198) fifo.4b
x4 XDRIVER Fifo.5a (cid:197)(cid:198) fifo.5b
x5 XDRIVER Fifo.6a (cid:197)(cid:198) fifo.6b
x6 XDRIVER Fifo.7a (cid:197)(cid:198) fifo.7b
Trang 131
CELL CELL Fifo.8a (cid:197)(cid:198) fifo.8b
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
2. Nhóm lệnh G.*
Được cài đặt trong thư mục SRC\GENERAL
a. Lệnh g.ask
b. Lệnh g.parser
c. Lệnh g.version
….
3. Nhóm lệnh R.* (chưa thực hiện chuyển đổi )
4. Nhóm lệnh S.* (chưa thực hiện chuyển đổi)
3.5.3.4 Cơ chế SendMessage trong GRASS5
Để có thể trao đổi thông tin qua lại giữa người sử dụng (hoặc lập trình viên) với thiết bị
Driver, Grass thiết lập một cơ chế Send Event được mô tả tổng quát như sau:
Khi người sử dụng các hàm của thư viện Display (có tiền tố là D_ ), hoặc các hàm thư •
viện của Raster (có tiền tố là R_ ), để thực hiện một công việc gì đó, giả sử là vẽ ra màn
hình một hình chữ nhật chẳng hạn, (hàm R_Box_Abs()… chẳng hạn), thì hàm này sẽ
không trực tiếp thực hiện vẽ mà nó sẽ gửi một EVENT là có tên là “hình chữ nhật”
chẳng hạn,… đến cửa sổ MONITOR hiển thị hiện tại, Driver của Monitor này sẽ bắt lấy
EVENT “hình chữ nhật” này, và thực hiện yêu cầu của EVENT là “vẽ hình chữ nhật” ra
màn hình MONITOR.
Nếu EVENT gửi đi có yêu cầu nhận kết quả trả về thì Driver sẽ tính toán kết quả cần •
thiết để trả về cho người dùng.
Các EVENT được xử lý theo nguyên tắc FIFO (First In First Out), EVENT tới trước •
Trang 132
được xử lý trước….
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Mô hình phác họa:
Programmer/User (cid:197)(cid:198) Display (cid:197)(cid:198) Raster (cid:197)(cid:198) Drivers
(cid:153)Cách thức Send một EVENT & nhận kết quả trả về:
- Mỗi monitor xi bất kỳ đều có 2 file fifo.ia, fifo.ib dùng để nhận và xử lý EVENT (xác
định trong file monitorcap ).
- Send một EVENT tới monitor xi đơn giản chỉ là mở file fifo.ia của monitor xi đó ra để ghi
EVENT vào
- Chú ý:
Các EVENT đã được quy định sẵn, EVENT được ghi vào file theo 1 định dạng cấu trúc đã
được quy định. Cấu trúc khi ghi 1 EVENT vào file như sau:
COMMAND_ESC EVENT_NAME PARAMETER1, PARAMETER2,…
Trong đó,
COMMAND_ESC : là EVENT đặc biệt, đã được quy định sẵn (mã là 127), dùng để
thể hiện sự bắt đầu của một EVENT mới
EVENT_NAME : tên của EVENT cần gửi đi
PARAMETER1,PARAMETER2, ….. : Các thông tin tham số gửi kèm theo event đó,
tùy theo loại event được gửi đi mà các tham
số này có thể có hoặc không.
Ví dụ:
Khi cần yêu cầu vẽ một hình chữ nhật với các tọa độ là (5, 10), (50, 25) ra màn hình, Grass
sẽ ghi vào file fifo.ia nội dung như sau:
Trang 133
COMMAND_ESC BOX_ABS 5 10 50 25
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Ghi chú:
Hàm dùng để ghi EVENT vào file fifo.ia là: _send_ident(“event”);
Hàm này bao gồm cả ghi vào COMMAND_ESC + EVENT
Các hàm dùng để ghi thông tin tham số vào thường dùng là:
_send_int(int*);
_send_char(char*);
_send_float(float*);
_send_text(char *text);
_send_int_array(int, int*);
_send_char_array(int, char*);
Trước khi ghi event vào file bằng hàm _send_ident(..) trên, chúng ta phải mở kết nối đến
Driver của Monitor hiện hành bằng hàm: R_Open_Driver()
// mở kết nối đến file fifo
// Send sự kiện BOX_ABS
// các thông tin tham số kèm theo, …left
// …top
// …right
int t; _send_ident(BOX_ABS); t = 5; _send_int(&t); t = 10; _send_int(&t); t = 50; _send_int(&t); t = 25; _send_int(&t);
// …bottom
if (R_Open_Driver()) { }
Lấy ví dụ trên, yêu cầu vẽ một hình chữ nhật:
Sau khi gửi EVENT đi, nếu là EVENT có yêu cầu nhận kết quả trả về thì kết quả trả về sẽ
Trang 134
được ghi vào file fifo.ib, chỉ cần đọc lên kết quả yêu cầu tương ứng.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
_get_int(int*); _get_float(float*); _get_text(char*); char*_get_text2(void); _get(char*, int);
Các hàm dùng để nhận kết quả trả về thông dụng là: (đọc từ file fifo.ib)
Lấy ví dụ gửi một EVENT có yêu cầu kết quả trả về, chẳng hạn là event SCREEN_TOP,
// mở kết nối đến file fifo
// biến lưu kết quả trả về
int Result; _send_ident(SCREEN_TOP);// Send sự kiện SCREEN_TOP _get_int(&Result);
// nhận kết quả trả về sau khi send y/c
if (R_Open_Driver()) { }
event này khi được gửi đi sẽ yêu cầu trả về tọa độ bên trên của màn hình hiện hành :
Result sẽ chứa kết quả trả về sau khi gửi yêu cầu SCREEN_TOP.
(cid:153) Cách thức nhận & xử lý một EVENT:
(cid:198) Các hàm trên đều cài đặt ở trong file src\ libes\ raster\ io.c
EVENT chỉ được xử lý khi có có ít nhất một MONITOR xi đang chạy (d.mon start=xi ) •
• Khi một MONITOR xi được khởi tạo bằng lệnh d.mon start=xi (i = 0, 1, 2…6), nó cũng
sẽ khởi động một process chạy song song liên tục, process này sẽ mở file fifo.ia để đọc
và kiểm tra liên tục các EVENT đang được ghi trong file này. Nó sẽ bắt lấy các EVENT
đó, và dựa vào EVENT đó là gì mà sẽ đọc tiếp cấu trúc các tham số truyền theo event và
đưa ra các xử lý thích hợp. (như vẽ ra màn hình, v.v…).
Chú ý là EVENT + tham số truyền ghi vào làm sao thì khi đọc lên phải đọc theo đúng •
Trang 135
cấu trúc như vậy. Ví dụ: khi nhận được event BOX_ABS thì phải đọc tiếp theo đúng 4
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
số liên tiếp nữa để lấy tiếp toạ độ cần vẽ của BOX_ABS. Không được đọc ít hay nhiều
hơn…Sẽ gây sai hoàn toàn hệ thống.
Nếu EVENT nhận được là event có yêu cầu trả về kết quả, thì kết quả sẽ được tính toán •
và trả về bằng cách ghi vào file fifo.ib tương ứng.
Ghi chú:
- Hàm đọc event từ file fifo.ia lên là : get_command(char*);
- Các hàm thường dùng để đọc thông tin các tham số kèm theo event là:
(đọc từ file fifo.ia - có sự tương ứng với các hàm ghi thông tin tham số ở trên)
read1(char*) get1(char*) REC(a, b) RECTEXT(x, s)
- Các hàm thường dùng để gửi trả lại kết quả cho User (đối với các event có yêu cầu kết
quả) là: ( ghi vào file fifo.ib )
SEND(a, b) SENDTEXT(x) RESULT(int)
// đọc event trong file fifo.1a
Ví dụ:
… char *event; get_command(&event); switch (event) {
case BOX_ABS:
REC(&l, sizeof l); REC(&t, sizeof t); REC(&r, sizeof r);
// nếu là yêu cầu vẽ hình chữ nhật // thì đọc tiếp 4 tọa độ vẽ kèm theo // … top // … right
Trang 136
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
// … bottom // thực hiện vẽ hcn ra màn hình
REC(&b, sizeof b); Box_abs(l, t, r, b); break;
// biến index
case SCREEN_TOP: // nếu yêu cầu tính tọa độ scr_top Screen_top(&index); // thì tính tọa độ scr_top gán cho SEND(&index, sizeof index); // trả kết quả index về cho User break;
}
(cid:153)Cấu trúc của file fifo.ia
(cid:198) Các hàm trên đều được cài đặt trong file src\ display\ devices\ lib\ command.c
Là một dãy các cấu trúc sự kiện, mỗi cấu trúc sự kiện có định dạng như đã nói là:
COMMAND_ESC EVENT_NAME [ PARAMETER1, PARAMETER2,… ]
(cid:153)Cấu trúc của file fifo.ib
trong đó, parameter là optional, tùy sự kiện được send mà có thể có hoặc không.
Là một dãy các kết quả được trả về tương ứng với sự kiện trong file fifo.ia, kết quả trả về
tuân theo nguyên tắc fifo, và kết quả trả về có thể là một, hoặc nhiều kết quả.
Trang 137
RESULT1 RESULT2 RESULT3 ……
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
(cid:153)Mô Hình Minh Họa Tổng Thể Cho Cơ Chế Send Event
Window MONITOR
Event Receive
[ Send Result ]
Fifo.1a
Fifo.1b
[ Receive Result ]
Event Request
DISPLAY REQUEST (Display/Raster)
Hình 3 - 4 Mô hình minh họa cơ chế Send Event trong GRASS5
Trang 138
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
(cid:153)Danh sách các EVENT:
Tên EVENT Mục Đích
BEGIN
Dùng để phát tín hiệu bắt đầu sẵn sàng nhận event (khi mở Driver fifo.ia)
RESPOND
GET_NUM_COLORS Event này dùng để lấy về số màu đang dùng để hiển thị window
STANDARD_COLORS Event này dùng để truyền thiết lập màu chuẩn cho window MONITOR.
COLOR Event này dùng để sử dụng màu color mới cho MONITOR
RGB_COLOR
Event này giống như COLOR, nhưng tham số màu được truyền với 3 thành phần là : Red, Green, Blue !
COLOR_TALBE_FIXED Tính toán bảng màu của XWindow và trả về trong biến NCOLORS
COLOR_TABLE_FLOAT với nhưng
Giống COLOR_TABLE_FLOAT, kết quả trả về là số thực.
Thiết lập giá trị color_offset mới COLOR_OFFSET
Thiết lập giá trị color_print mới COLOR_PRINT
CONT_ABS Event này yêu cầu vẽ đường thẳng tới 2 điểm x, y cho trước
CONT_REL Giống với CONT_ABS, nhưng vẽ từ điểm hiện tại
Trang 139
BOX_ABS Event này yêu cầu vẽ hình chữ nhật với toạ độ 4 điểm cho trước.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
BOX_REL Giống với BOX_ABS nhưng vẽ từ điểm hiện tại.
ERASE
bằng send
MONITOR khi nhận được event này sẽ thực hiện việc xoá toàn bộ màn event cách hình BOX_ABS với toạ độ hình chữ nhật là toạ độ màn hình.
GET_LOCATION_WITH_BOX
Sử dụng thiết bị chuột để lấy về trạng thái của các nút chuột và vị trí toạ độ mới của MONITOR.
GET_LOCATION_WITH_LINE Tương tự với GET_LOCATION_WITH_BOX
GET_LOCATION_WITH_POINTER Tương tự như trên
GRAPH_CLOSE
Khi MONITOR nhận được EVENT này thì nó sẽ đóng MONITOR và kết thúc process kiểm tra EVENT.
LINE_MOD
MOVE_ABS Di chuyển vị trí toạ độ hiện tại trên màn hình sang toạ độ mới
MOVE_REL Giống với MOVE_ABS, nhưng di chuyển tự vị trí hiện tại
… RASTER_CHAR
… RASTER_INT
… RGB_RASTER
… RGB_COLORS
POLYGON_ABS Yêu cầu MONITOR vẽ ra hình Polygon với toạ độ cho trước
Trang 140
Giống với POLYGON_ABS nhưng POLYGON_REL
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
vẽ từ vị trí toạ độ hiện tại.
POLYLINE_ABS Yêu cầu MONITOR vẽ ra hình Polyline với tập điểm cho trước
POLYLINE_REL Giống với POLYLINE_ABS, nhưng vẽ từ vị trí toạ độ hiện tại.
POLYDOTS_ABS Yêu cầu MONITOR vẽ ra hình tập điểm với tập điểm cho trước
POLYDOTS_REL Giống với POLYDOTS_ABS, nhưng vẽ từ vị trí toạ độ hiện tại.
Reset lại colors, có tính đến min, max RESET_COLORS
RESET_COLOR Reset lại colors, không tính đến min, max
SCREEN_LEFT Yêu cầu trả về giá trị của toạ độ TRÁI của MONITOR
SCREEN_TOP Yêu cầu trả về giá trị của toạ độ TRÊN của MONITOR
SCREEN_RITE Yêu cầu trả về giá trị của toạ độ PHẢI của MONITOR
SCREEN_BOT Yêu cầu trả về giá trị của toạ độ DƯỚI của MONITOR
SET_WINDOW Thiết lập lại vị trí (top, left, right, bottom) của MONITOR
GET_TEXT_BOX Lấy về giá trị text trong box có vị trí toạ độ (t, l, r, b)
FONT Khởi tạo font và trả về ID của font khởi tạo
Trang 141
TEXT Định dạng lại đoạn Text cho trước bằng hàm soft_text(…)
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
TEXT_SIZE Trả về kích thước của đoạn Text cho trước.
Quay một đoạn text cho trước. TEXT_ROTATION
PANEL_SAVE Save một Panel cho trước (một vùng Region trên màn hình) vào file
PANEL_RESTORE Load một Panel đã xây trước đó lên màn hình.
Huỷ một Panel đã lưu. PANEL_DELETE
Tạo một PAD mới vào xâu pad_list PAD_CREATE
Ghi chú: Các định nghĩa về PAD sẽ được nói rõ hơn ở phần sau.
Trả về PAD đang sử dụng hiện tại PAD_CURRENT
PAD_DELETE Huỷ một PAD cho trước ra khỏi xâu pad_list
Trả về ID của PAD cho trước PAD_INVENT
Trả về con trỏ đầu xâu pad_list PAD_LIST
PAD_SELECT Chọn một PAD cho trước làm PAD hiện hành.
PAD_GET_ITEM Trả về xâu Item của một PAD cho trước
PAD_SET_ITEM Thiết lập xâu Item của một PAD cho trước.
Thêm Items vào một PAD cho trước PAD_APPEND_ITEM
Xoá Items của một PAD cho trước. PAD_DELETE_ITEM
Trang 142
PAD_LIST_ITEMS Liệt kê xâu Items của một PAD cho trước.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
3.5.3.5 Khái niệm hệ thống đồ họa XWindow trong Linux
Trong Unix, màn hình (display) được quản lý bởi một chương trình duy nhất là server,
server sẽ nhận những yêu cầu vẽ và xóa từ những chương trình cần sử dụng màn hình
(được gọi là client). Giao tiếp giữa client và server được thực hiện thông qua giao thức
X (X protocol). Giao thức này có những đặc điểm sau:
(cid:153) Server và client có thể cùng nằm trên một máy, hoặc cũng có thể nằm trên
nhiều máy, liên lạc nhau thông qua một mạng máy tính.
(cid:153) Chỉ có server là bị phụ thuộc vào phần cứng máy tính (màn hình), còn giao
thức X lại không phụ thuộc vào phần cứng, vì vậy chương trình client có thể
chạy và sử dụng màn hình của một máy tính khác từ xa
(cid:153) Server có thể xử lý nhiều yêu cầu của nhiều client cùng lúc trên cùng một
màn hình, các client này cũng có thể giao tiếp với nhau thông qua server
(cid:153) Một client có thể nối kết với nhiều server
Mỗi client gửi yêu cầu tạo ra hoặc bỏ đi một hoặc nhiều cửa sổ trên màn hình. Các cửa
sổ được tổ chức theo dạng cây, đầu tiên là cửa sổ gốc của màn hình, mỗi client sẽ tạo
ra ít nhất một cửa sổ top-level của mình, những cửa sổ còn lại sẽ là con của cửa sổ top-
level này. Khi một cửa sổ con vượt ra ngoài giới hạn của cửa sổ cha, phần vượt quá sẽ
bị cắt bỏ.
Ðối với server, cửa sổ cũng như tất cả những đối tượng vẽ khác đều là resource, trong
đó có một số resource quan trọng:
(cid:153) Pixmap: là một vùng chữ nhật vẽ được, nhưng không nằm trên màn hình,
pixmap được tạo thành từ những đơn vị nhỏ nhất là pixel. Mỗi pixel có một
độ sâu, được biểu diễn bằng một số bit (còn gọi là plane). Vì vậy mỗi pixel
có một giá trị phụ thuộc vào độ sâu của vùng vẽ. Một pixmap có độ sâu là
Trang 143
một bit được gọi là bitmap, từng pixel trong một bitmap có 2 giá trị: 0 và 1
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
(cid:153) Colormap là cách xác định màu từ các giá trị của pixel, mỗi màu được tổ
hợp từ 3 giá trị mức độ đỏ (red), xanh dương (green) và xanh lá cây (blue)
(RGB). Mỗi cửa sổ có một colormap được xác định màu của từng pixel.
(cid:153) Font
(cid:153) Cursor là một đối tượng chứa thông tin cần thiết để biểu diễn đồ họa cho
con trỏ chuột. Nó bao gồm một source bitmap, một shape bitmap, một
hotspot (vị trí hiện thời của con trỏ), và 2 màu.
(cid:153) Graphic context (GC) là một tập hợp các thuộc tính để xác định cách các
tác vụ trên một vùng vẽ sẽ ảnh hưởng đến vùng này. Mỗi tác vụ sẽ sử dụng
một GC do client cung cấp, ví dụ một vài thuộc tính của GC là foreground
pixel, background pixel, bề dày đường, vùng cắt bỏ (clip).
(cid:153) Property là một cấu trúc dữ liệu có tên của một cửa sổ, các client dùng
property để giao tiếp với nhau.
Mỗi client nối kết với một hoặc nhiều server, chúng trao đổi các request (yêu cầu),
reply (trả lời), error (báo lỗi), event (sự kiện). Client gửi request đến server để yêu cầu
vẽ hoặc xóa, server gửi reply lại nếu client có yêu cầu thông tin, khi gặp lỗi server sẽ
gửi thông báo error cho client. Server sẽ gửi event để thông báo các thay đổi trạng thái,
như khi có một phím được nhấn hoặc con trỏ chuột bị di chuyển.
Các chương trình giao tiếp với X Server như thế nào ?
Các chương trình không trực tiếp giao tiếp với X server, chúng sẽ sử dụng các thư viện
có sẵn để giao tiếp. Có 3 thư viện như vậy là Xlib, X Toolkit Intrinsics (Xt), và Motif.
i) Thư viện Xlib
X protocol có sẵn một interface được giao tiếp với X server, được gọi là Xlib. Các
Trang 144
chức năng chính của Xlib có như sau:
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
(cid:153) Các lệnh để tạo ra và quản lý các resource của server, bao gồm cửa sổ, pixmap,
font, cursor, GC, và property
(cid:153) Lệnh để thêm chữ và hình ảnh vào các vùng vẽ
(cid:153) Cấu trúc dữ liệu được chứa các event, lệnh để chọn và đọc các event
(cid:153) Lệnh để sử dụng các colormap
(cid:153) Lệnh đọc và ghi chữ
(cid:153) X resource manager (Xrm) là một cơ sở dữ liệu các tùy chọn được xác định bởi
người sử dụng chương trình.
Xrm là ý tưởng chủ đạo của X: người sử dụng và chương trình phải tự điều khiển hình
dáng, cách tương tác và màu sắc của đối tượng đồ họa. Những yếu tố này được biểu
diễn bằng các resource, một chương trình sẽ có các giá trị mặc định cho những
resource này, và người sử dụng sẽ sửa lại nếu cần thiết
Resource là một bộ ba gồm tên, class, và giá trị. Một class có thể chứa một tập các
resource khác tên nhau. Resource có thể được tổ chức phân cấp trong một chương
trình. Tên hoặc class đầy đủ của một resource sẽ là tên bắt đầu từ tên hoặc class của
chương trình và kết thúc bằng tên hoặc class của resource
Resource manager cho phép một chương trình hoặc người sử dụng xác định các
resource: trong một file, trên dòng lệnh, hoặc gọi một lệnh Xrm trong chương trình.
ii) Thư viện Xt
Mặc dù Xlib đã cung cấp các phương tiện cơ bản được giao tiếp với X server, những
lệnh này là rất cơ bản và sẽ bắt lập trình viên viết rất nhiều
X cũng kèm theo một thư viện, X Toolkit Intrinsics (Xt), để cung cấp một số hàm mức
Trang 145
độ cao hơn. Các thành phần quan trọng nhất là:
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
(cid:153) Các đối tượng, còn gọi là widget, dùng để chứa dữ liệu và interface đối với
người sử dụng
(cid:153) Quản lý hình dáng các widget
(cid:153) Phân phối và xử lý các event
Widget
Widget class là một tập hợp các procedure và cấu trúc dữ liệu dùng chung cho tất cả
widget thuộc cùng class. Một đối tượng widget chứa các procedure và dữ liệu riêng của
mình. Xt có sẵn và đặt tên sẵn cho các class widget, người lập trình sẽ tạo ra và đặt tên
cho các đối tượng widget.
iii) Thư viện Motif
Motif cung cấp thêm nhiều lệnh để tạo ra các widget phục vụ cho những mục đích khác
nhau khi giao tiếp với người sử dụng. Sau đây là tóm tắt các chức năng này:
Kiểu dáng trực quan
Các widget của Motif đều có các kiểu dáng trực quan, các đường biên có màu sắc khác
nhau tạo cảm giác widget nổi lên hoặc chìm sâu xuống so với nền. Một widget đang là
đối tượng tác động của bàn phím sẽ có đường biên được tô sáng. Khi con trỏ chuột trên
một button và người sử dụng nhấn nút Btn1, màu của button sẽ thay đổi tạo cảm giác
được nhấn. Tất cả các màu sắc hình dáng của widget đều được chọn mặc định, người
sử dụng hoặc chương trình cũng có thể chọn riêng cho mình màu sắc hoặc ảnh pixmap.
Motif có một cơ chế kéo và thả rất đầy đủ để truyền dữ liệu, dữ liệu được kéo từ một
điểm bằng nút Btn2 sang điểm đích, khi người sử dụng thả chuột, dữ liệu sẽ được
Trang 146
chuyển, sao chép hoặc liên kết đến đích.
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Sử dụng Xlib, Xt và Motif
Xt được xây dựng trên Xlib, và Motif lại được xây dựng trên Xt. Tuy nhiên Xt không
thay thế hết các interface của Xlib, và Motif cũng không thay thế hết các interface của
Xt. Bất kỳ chương trình Motif nào cũng phải sử dụng các lệnh Xt cơ bản được khởi
tạo, quản lý các widget, xử lý các resource, tạo ra các hàm callback, và để vào vòng lặp
xử lý event.
Theo quy ước, tên của các hàm và cấu trúc dữ liệu của Xlib bắt đầu bằng ‘X’, của Xt
bắt đầu bằng ‘Xt’, của Motif bắt đầu bằng ‘Xm’.
Ðể viết chương trình sử dụng Motif, lập trình viên trước hết phải quen với các chương
trình Xt đơn giản và hiểu biết về Xlib.
3.5.3.6 Cài đặt và sử dụng các hàm X (Xlib) trên Window32
Để thực hiện các thao tác đồ họa trên MONITOR, Grass sử dụng hệ thống thư viện cơ
bản nhất của Unix, đó là XLIB. Hệ thống hàm X của Xlib nói theo nghĩa nào đó, tương
tự như các hàm đồ họa API trên hệ điều hành Window.
Khi MONITOR được yêu cầu vẽ cái gì đó ra màn hình thì Driver của nó sẽ sử dụng thư
viện các hàm vẽ của nó mà bao bọc bên trong đó là thư viện các hàm X.
int draw_line (int cur_x, int cur_y, int x, int y) { …………………….. XDrawLine(dpy, bkupmap, gc, cur_x, cur_y, x, y); needs_flush = 1; return 0; }
Trang 147
Ví dụ:
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Cấu trúc dữ liệu của các hàm X rất phức tạp, được tổ chức theo nhiều xâu kép nối với
nhau, tạo thành một dãy các phần tử NT_WINDOW, cùng với các khái niệm Display,
Screen v.v…
Ngoài ra, còn phải xử lý chuyển các sự kiện của XWindow sang sự kiện của Window,
xử lý cấu trúc dữ liệu của các cửa sổ….
Vì thế, việc viết lại hệ thống các hàm X của XWindow trên nền MS Window là một
công việc vô cùng phức tạp, khó khăn nếu không muốn nói là nan giải (!).
Tuy nhiên, không phải bài toán khó nào cũng không có lời giải. Rất may mắn cho
chúng ta, nhóm phát triển dự án Cygwin, trong nỗ lực cố gắng xây dựng một môi
trường giả lập Linux thật hoàn hảo trên Window, cùng với mong muốn Grass5 cũng có
thể chạy trên nền Window thông qua Cygwin, đã phát triển hệ thống các hàm thư viện
giả lập hệ thống XLIB của Unix trên Window. (Open Source)
Source code nằm trong thư mục src\ display\ devices\ windows\ libW11\
Trong thư mục này có các thư mục con sau:
X11\ : Chứa các file tiêu đề (.h) mô tả thư viện Xlib
Muốn sử dụng Xlib, chỉ cần include các file này.
w32\ : Chứa source code chính của các thư viện Xlib, sẽ được dịch thành DLL
wrap\ : là thư mục chứa lớp bao bọc của xlib, chúng ta sẽ sử dụng các hàm X
thông qua lớp này, không gọi trực tiếp xuống thư viện Xlib
Tuy nhiên, mặc dù các hàm thư viện xlib này được viết bằng WinAPI, nhưng chúng
chỉ được xây dựng để chạy trên nền Cygwin, và chúng chỉ là bộ thư viện cơ sở cấp
thấp. Chúng được viết giả lập lại các hàm X trên Unix, nhưng chúng ta không thể gọi
Trang 148
sử dụng trực tiếp các hàm này được. Muốn sử dụng được, chúng ta phải cần đến một
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
lớp bao bọc bên trên các hàm này, lớp này sẽ xử lý, khởi tạo sơ bộ những yếu tố cần
thiết để sẵn sàng gọi đến bộ thư viện X này.
Cụ thể là, source code bộ thư viện xlib.c sẽ được chúng ta chủ động đóng gói lại thành
một thư viện động DLL tên là libG11.dll, sau đó chúng ta sẽ dùng các file khác cài đặt
lại prototype của các hàm X, có xử lý sơ bộ trước khi lại gọi xuống chính các hàm X
đó trong thư viện động libG11.dll.
Ví dụ:
Thư viện Xlib.c (đã xây dựng thành libG11.dll) có hàm XopenDisplay(int a, int b, int
c);
Để sử dụng hàm này, ta không gọi trực tiếp từ thư viện libG11.dll mà ta phải xây dựng
một hàm khác cùng tên, làm các xử lý sơ bộ, trước khi gọi làm hàm thật sự của Xlib,
void XOpenDisplay(int a, int b, int c) {
// Các xử lý sơ bộ int test = Set_Atom(_register_class(..)); //chỉ là ví dụ //Sau đó mới gọi các hàm Xlib trong libG11.dll LoadDLL_XOpenDisplay(a, b, c);
}
như sau:
Trên đây chỉ là minh họa thuật giải, còn cụ thể, xem trong các file wrap\wrap.c &
wrap\xwrappers.gen
Ghi chú:
Load một hàm thư viện từ DLL ngoài cách sử dụng file .lib trong Setting của VC++, ta
còn có thể load trực tiếp từ file .DLL mà không cần file .lib, bằng các hàm sau:
LoadLibrary();
Trang 149
GetProcAddress();
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Ví dụ:
// load thư viện libG11.dll // đọc con trỏ hàm “name”
void *f = NULL; _lib = LoadLibrary(“libG11.dll”); f = GetProcAddress(_lib,name); return f; // trả về con trỏ hàm của hàm “name”
static void* _lib; // hàm sau load một hàm tên “name” trong DLL lên để sử dụng void* _loadfunc(char *name) { }
Load một hàm thư viện:
//khai báo dạng thức hàm của hàm XOpenDisplay trong thư viện typedef Display * (proto_XOpenDisplay)(const char *name); //khai báo con trỏ hàm XOpenDisplay static proto_XOpenDisplay *func_XOpenDisplay = NULL; Display * XOpenDisplay(const char *name) {
//load hàm thư viện XOpenDisplay lên
func_XOpenDisplay=(proto_XOpenDisplay *)_loadfunc("XOpenDisplay");
//gọi thực hiện nó return (func_XOpenDisplay)(name);
}
Trang 150
Gọi thực hiện một hàm thư viện:
Chương 3: Quá trình chuyển đổi GRASS5 từ Unix lên Windows
Mô Hình Xây Dựng Thư Viện XLIB:
USER / GRASS
XLIB LIBRARY
Wrap.c
libG11.dll
ntutil.c
xlib.c
event.c
Hình 3 - 5 Kiến trúc thư viện XLIB
Trang 151
Chương 4: Tổng kết
Chương 4 : Tổng Kết
4.1 Kết Luận Với GRASS5, chúng em đã chuyển đổi được hầu hết các thư viện (gis, display, raster,
bitmap, v.v…) và dịch vụ nền cơ bản, các xử lý tính toán, và một phần nhỏ của nhóm
lệnh hiển thị bên trên (d.mon, d.rast … ). Điểm nhấn của dự án là đã khởi động và hiển
thị được cửa sổ MONITOR của GRASS với XWindow trên môi trường Windows.
Khối lượng mã nguồn của GRASS5 tuy đồ sộ và phức tạp, nhưng với những gì đã đạt
được, chúng em tin rằng có thể tiếp tục chuyển đổi được hết những khối lệnh còn lại.
Nếu có nhiều thời gian hơn nữa, dự án chắc chắn sẽ thành công rực rỡ.
4.2 Hướng Phát Triển Trong thời gian vừa qua, chúng em đã đặt được cái nền cơ bản, tạo nền tảng vững chắc
để phát triển tiếp sau này. Với khối lượng mã nguồn đã chuyển được, chương trình có
thể được phát triển tiếp, chuyển đổi nhiều hơn nữa các chức năng mạnh mẽ của
GRASS5, phần mềm mà đến bây giờ đã được phát triển đến phiên bản 5.7, một cách
Trang 152
trọn vẹn.
Tài liệu tham khảo
Tài Liệu Tham Khảo Albrecht, J. : GTZ-handbook GRASS. Vechta, Germany, 1992 Hoặc xem tại địa chỉ sau: http://www.laum.uni-hannover.de/iln/grass/ Byars, B.W., Clamons, S.F. : GRASS 4.2 Reference Manual. Waco, U.S.A, 1997 Hoặc xem tại địa chỉ sau: http://www.baylor.edu/~grass/ Fox, J. : RIM database system. Installers manual. University of Washington, 1989 Fox, J. : RIM database system. Users manual. University of Washington, 1989 Harmon, V., Shapiro, M. : GRASS tutorial: Image processing. CERL, Champaign, Illinois, 1992 Jensen, J. R. : Introductory Digital Image Processing: A remote sensing perspective. Second Edition. New Jersey, 1996 Larson, M., Shapiro, M., Tweddale, S. : Performing map calculations on GRASS data : r.mapcalc programming tutorial. CERL, Champaign, Illinois, 1991 Hoặc xem tại địa chỉ sau: http://www.laum.uni-hannover.de/iln/grass/ Lillesand, Th. M., Kiefer, R. W. : Remote sensing and image interpretation. New York, 1994. Neidig, C.A., Gerdes, D., Kos, Ch. : GRASS 4.0 map digitizing manual: v.digit. CERL, Champaign, Illinois, 1991. Neteler, M. : Das GRASS Handbuch. Ein problemorientierter Leitfaden. 3. Auflage, Hannover, Germany, 1998. Phiên bản trước có tại: http://www.laum.uni-hannover.de/iln/grass/handbuch/ Shapiro, M., Westerveld, J. : GRASS programmer's manual. CERL, Champaign, Illinois, 1991. Shapiro, M., Westerveld, J. : GRASS user's manual. CERL, Champaign, Illinois, 1991.
Trang 153
Phụ lục
Phụ Lục
Một số kỹ thuật chuyển đổi
(cid:198) Kỹ thuật ReDirect Output Stream
Kỹ thuật này dùng để chuyển hướng lại output, thay vì xuất ra dòng stdout, chúng ta sẽ
chuyển hướng sang một ListBox. Sử dụng kỹ thuật này chủ yếu để bắt lấy output của
các hàm printf(..), fprintf(..), tạo dễ dàng cho việc xử lý.
Chi tiết của kỹ thuật này, xem trong mã nguồn chương trình.
(cid:198) Kỹ thuật xử lý PAD của GRASS
Khi tạo hay xử lý trên cửa sổ XWindow thì GRASS có sử dụng xâu liên kết đôi
PAD...(cấu trúc xâu PAD và các xử lý trên xâu đó được định nghĩa độc lập trong 2 file
pad.h và pad.c trong thư mục device/lib)
Khi cần thao tác trên cửa sổ XWindow, các hàm R_xxx_Pad sẽ được gọi.
Các hàm R_xxx_Pad này sẽ thực hiện bằng cách gửi sự kiện cùng với tham số dữ liệu
kèm theo sự kiện đó vào file fifo.1a, khi đó, bộ xử lý command (thread) sẽ đón lấy sự
kiện và dữ liệu kèm theo này để xử lý bằng cách gọi lại các hàm PAD chuẩn đã được
định nghĩa ở trên như create_pad(), find_pad() v.v... để thực hiện và trả kết quả xử lý
được về (bằng cách ghi vào file fifo.1b).
PAD chẳng qua là một xâu kép như sau:
Trang 154
pad1 <=> pad2 <=> pad3 <=> ...<=> pad n
Phụ lục
Mỗi PAD có một tên định danh riêng, và một danh sách liên kết ITEM
Mỗi danh sách liên kết ITEM lại nắm giữ một xâu LIST, mỗi phần tử LIST có giá trị
riêng.
Bởi vậy, thường hay có câu sau đây:
"...duyệt hết các Item của Pad này "
"...duyệt hết các List của Item này "
Ở đây, xâu này bắt đầu bằng biến con trỏ toàn cục "padlist" trong file pad.c
Và pad được khởi tạo ban đầu create_pad("").
Hàm create_pad (char *name) :
Để tạo ra một PAD mới có tên là name, rồi gắn nó vào đầu xâu
pad_mới <=> pad1 <=> pad2 <=> ...<=> pad n
Hàm find_pad (char *name) :
Trả về con trỏ đến một phần tử pad có tên là name trong xâu, nếu có.
Sự Kiện PAD_GET_ITEM:
Để lấy giá trị của toàn bộ danh sách LIST trong ITEM của PAD hiện tại (currentPad).
Cụ thể là sau khi gửi sự kiện PAD_GET_ITEM với tham số là tên của Item (chẳng hạn
Trang 155
như là "cur_w" )
Phụ lục
//gửi tiếp tham số là tên của Item.
_send_ident(PAD_GET_ITEM); //gửi sự kiện _send_text("cur_w"); _get_char(&result); // ghi thực sự vào file và nhận lại kết quả ................................................................................................. // Tới đây thì thread chạy ngầm bên kia của chúng ta // sẽ bắt lấy và xử lý Sự Kiện này RECTEXT(text, text_size); /* đọc lên tham số được kèm theo:
tên của Item, cụ thể ở đây là chuỗi "cur_w" */
// của current pad items có tên là // text
if (curpad == NULL){ // nếu không tồn tại Pad hiện tại RESULT(NO_CUR_PAD); // thì trả về kết quả error break;
} item = find_item(curpad, text); // tìm trong danh sach Items if (item == NULL) { RESULT(NO_ITEM); // nếu không tìm thấy thì // trả về kết quả error
break; } RESULT(OK); // đã tìm thấy Item có tên như thế,
//trả về kết quả OK trước!
// ghi liên tục vào file chuỗi // danh sách các giá trị của List
for (list = item->list; list != NULL; list = list->next) //duyệt List if (*list->value) //của Item vừa tìm thấy SENDTEXT(list->value); SENDTEXT(""); // kết thúc bằng ký hiệu rỗng ""
/* Tới đây thì kết thúc Thread bắt sự kiện này */ .................................................................................................
if (result == OK) // nếu mà kết quả trả về là OK
get_list(list, count); // lấy lên danh sách giá trị của List vừa được
// ghi vào hồi nãy ở trên ....
Trang 156
D_New_Window(name, top, bottom, left, right):
Phụ lục
Hàm này dùng để tạo ra một pad mới có tên là "full_screen", sau đó chọn nó là Pad
hiện hành, sau đó, thiết lập giá trị ITEM có tên "d_win" của nó các giá trị top,
bottom, right, left của cửa sổ cần tạo. Sau đó, gọi hàm D_Show_Window để show ra
màn hình.....
Các hàm khác đều tương tự….
Trang 157
HẾT
