add all

.dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Cài đặt các gói phụ thuộc
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Sao chép mã nguồn vào container
+COPY . .
+
+# Cài đặt biến môi trường
+ENV SOLID_DATA_PATH="/app/solid_data"
+
+# Mở cổng cho ứng dụng
+EXPOSE 7860
+
+# Khởi chạy ứng dụng
+CMD ["python", "app.py"]

.gitignore

@@ -0,0 +1,35 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Local development settings
+.env
+.env.local
+
+# Logs
+logs/
+*.log
+
+# Data files (uncomment if you don't want to commit data files)
+# solid_data/
+# *.npz
+
+# Jupyter notebook checkpoints
+.ipynb_checkpoints/

README.md

@@ -1,11 +1,96 @@
----
-title: Soil Data
-emoji: 🔥
-colorFrom: green
-colorTo: indigo
-sdk: docker
-pinned: false
-license: unknown
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Solid Data API
+
+API để tra cứu dữ liệu dựa trên tọa độ latitude và longitude.
+
+## Giới thiệu
+
+API này cho phép người dùng truy vấn dữ liệu từ các tệp SolidData dựa trên tọa độ vị trí (latitude và longitude). API sẽ trả về chuỗi giá trị từ tất cả các lớp dữ liệu tại vị trí đó.
+
+## Cài đặt
+
+### Yêu cầu
+
+- Python 3.8 trở lên
+- Các thư viện được liệt kê trong `requirements.txt`
+
+### Cách cài đặt
+
+1. Clone repository
+```bash
+git clone https://huggingface.co/spaces/l1aF2027/Solid-Data
+cd Solid-Data
+```
+
+2. Cài đặt các thư viện phụ thuộc
+```bash
+pip install -r requirements.txt
+```
+
+3. Đặt dữ liệu SolidData vào thư mục `solid_data/`
+
+4. Chạy ứng dụng
+```bash
+python app.py
+```
+
+## Cách sử dụng API
+
+### Endpoint
+
+- `POST /get_data`: Trả về giá trị dữ liệu tại tọa độ được chỉ định
+
+### Cấu trúc request
+
+```json
+{
+  "latitude": 10.123,
+  "longitude": 106.456
+}
+```
+
+### Cấu trúc response
+
+```json
+{
+  "values": "[0.0, 1.0, 0.0, 0.0, ...]",
+  "status": "success"
+}
+```
+
+### Ví dụ sử dụng với curl
+
+```bash
+curl -X 'POST' \
+  'https://[your-username]-solid-data-api.hf.space/get_data' \
+  -H 'accept: application/json' \
+  -H 'Content-Type: application/json' \
+  -d '{"latitude": 10.123, "longitude": 106.456}'
+```
+
+### Endpoints khác
+
+- `GET /health`: Kiểm tra trạng thái hoạt động của API
+- `GET /data_info`: Lấy thông tin về các tệp dữ liệu đã được tải
+
+## Triển khai trên Hugging Face Spaces
+
+API này được thiết kế để dễ dàng triển khai trên Hugging Face Spaces. Các tệp cấu hình cần thiết đã được bao gồm:
+- `Dockerfile`: Cấu hình Docker để xây dựng container
+- `requirements.txt`: Danh sách các thư viện Python cần thiết
+
+## Cấu trúc thư mục
+
+```
+.
+├── app.py                # Mã nguồn chính của API
+├── retrieval_app.py      # Module để tải và truy xuất dữ liệu
+├── solid_data/           # Thư mục chứa dữ liệu (các tệp .npz)
+├── requirements.txt      # Danh sách các thư viện cần thiết
+├── Dockerfile            # Cấu hình Docker để triển khai
+└── README.md             # Tệp hướng dẫn này
+```
+
+## Lưu ý
+
+- Đảm bảo rằng tệp `solid_data.py` chứa lớp `SolidData` đã được đặt trong thư mục làm việc
+- Thư mục `solid_data/` phải chứa các tệp .npz có cấu trúc phù hợp

app.py

@@ -0,0 +1,95 @@
+from fastapi import FastAPI, HTTPException
+import uvicorn
+from pydantic import BaseModel
+from typing import List, Optional
+import numpy as np
+import os
+from tqdm.auto import tqdm
+import pandas as pd
+from solid_data import SolidData
+from retrieval_app import RetrievalSolidData
+
+# Khởi tạo FastAPI app
+app = FastAPI(
+    title="Solid Data API",
+    description="API để tra cứu dữ liệu dựa trên tọa độ latitude và longitude",
+    version="1.0.0"
+)
+
+# Model dữ liệu đầu vào
+class CoordinateRequest(BaseModel):
+    latitude: float
+    longitude: float
+
+# Model dữ liệu đầu ra
+class DataResponse(BaseModel):
+    values: str
+    status: str = "success"
+
+# Biến global để lưu đối tượng RetrievalSolidData
+solid_data_app = None
+
+# Hàm khởi tạo dữ liệu - sẽ được gọi khi server khởi động
+@app.on_event("startup")
+async def startup_event():
+    global solid_data_app
+    solid_data_path = os.environ.get("SOLID_DATA_PATH", "./solid_data")
+    print(f"Khởi tạo dữ liệu từ thư mục: {solid_data_path}")
+    solid_data_app = RetrievalSolidData(solid_data_path)
+    print("Khởi tạo dữ liệu hoàn tất")
+
+# API endpoint để lấy dữ liệu dựa trên tọa độ
+@app.post("/get_data", response_model=DataResponse)
+async def get_data(request: CoordinateRequest):
+    global solid_data_app
+    
+    if solid_data_app is None:
+        raise HTTPException(status_code=500, detail="Hệ thống dữ liệu chưa được khởi tạo")
+    
+    try:
+        # Lấy dữ liệu từ RetrievalSolidData
+        df_data = solid_data_app.get_data(request.longitude, request.latitude)
+        
+        # Sắp xếp dữ liệu theo thứ tự như yêu cầu
+        new_order = ['Elevation', 'SlopesCl1', 'SlopesCl2', 'SlopesCl3', 'SlopesCl4', 'SlopesCl5', 'SlopesCl6', 
+                    'SlopesCl7', 'SlopesCl8', 'AspectClN', 'AspectClE', 'AspectClS', 'AspectClW', 'AspectClU', 
+                    'WAT', 'NVG', 'URB', 'GRS', 'FOR', 'CULTRF', 'CULTIR', 'CULT', 'sq1', 'sq2', 'sq3', 'sq4', 
+                    'sq5', 'sq6', 'sq7', 'LandMask']
+        
+        df_data['name'] = pd.Categorical(df_data['name'], categories=new_order, ordered=True)
+        df_data = df_data.sort_values('name').reset_index(drop=True)
+        
+        # Chuyển cột value thành một chuỗi dạng [x1, x2, ...]
+        values_list = df_data['value'].tolist()
+        values_str = str(values_list).replace("'", "")
+        
+        return DataResponse(values=values_str)
+    
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=f"Lỗi dữ liệu: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Lỗi hệ thống: {str(e)}")
+
+# API endpoint để kiểm tra trạng thái
+@app.get("/health")
+async def health_check():
+    return {"status": "ok"}
+
+# API endpoint để lấy thông tin về dữ liệu
+@app.get("/data_info")
+async def get_data_info():
+    global solid_data_app
+    
+    if solid_data_app is None:
+        raise HTTPException(status_code=500, detail="Hệ thống dữ liệu chưa được khởi tạo")
+    
+    try:
+        info_df = solid_data_app.get_data_info()
+        return {"data_info": info_df.to_dict(orient="records")}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Lỗi hệ thống: {str(e)}")
+
+# Chạy ứng dụng nếu file này được thực thi trực tiếp
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))  # Hugging Face Spaces sử dụng cổng 7860
+    uvicorn.run("app:app", host="0.0.0.0", port=port, reload=True)

prepare_solid_data.py

@@ -0,0 +1,113 @@
+import json
+import os
+from solid_data import SolidData
+
+class ProcessingSolidData:
+    def __init__(self, input_root="data", output_root="solid_data", data_info=None):
+        """
+        Khởi tạo đối tượng GenSolidData với thông tin thư mục và ánh xạ.
+        - input_root: Thư mục chứa các tệp ASC (ví dụ: 'data').
+        - output_root: Thư mục lưu kết quả (ví dụ: 'solid_data').
+        - data_info: Dictionary chứa filename, name và dtype dữ liệu.
+        """
+        self.input_root = input_root
+        self.output_root = output_root
+        # Kiểm tra nếu data_info không được cung cấp, tạo dictionary trống
+        self.data_info = data_info if data_info else {}
+
+    def load_data_info(self, filename="data_info.json"):
+        """
+        Đọc file JSON và trả về dictionary ánh xạ từ filename sang name và dtype.
+        - filename: Đường dẫn đến file JSON chứa bộ ánh xạ.
+        """
+        with open(filename, "r") as f:
+            self.data_info = json.load(f)
+        return self.data_info
+
+    def process_asc_files(self):
+        """
+        Duyệt qua tất cả tệp .asc trong input_root, đọc và lưu vào output_root với cấu trúc tương ứng.
+        """
+        # Duyệt qua tất cả thư mục và tệp trong input_root
+        for root, dirs, files in os.walk(self.input_root):
+            for file in files:
+                if file.endswith(".asc"):  # Chỉ xử lý tệp .asc
+                    # Đường dẫn đầy đủ của tệp .asc
+                    asc_path = os.path.join(root, file)
+                    
+                    # Tên tệp không có đuôi (sẽ dùng làm name và tên thư mục lưu)
+                    file_name = os.path.splitext(file)[0]
+                    
+                    # Ánh xạ file_name sang name và dtype nếu có trong dictionary
+                    data_info = self.data_info.get(file_name, {"name": file_name, "dtype": "float", "description": "Unknown"})
+                    name = data_info["name"]
+                    dtype = data_info["dtype"]
+                    description = data_info["description"]
+                    
+                    # Đường dẫn tương đối từ input_root
+                    relative_path = os.path.relpath(root, self.input_root)
+                    if relative_path == ".":
+                        output_dir = os.path.join(self.output_root, file_name)
+                    else:
+                        output_dir = os.path.join(self.output_root, relative_path, file_name)
+
+                    print(f"Đang xử lý: {asc_path} -> {output_dir}")
+                    
+                    try:
+                        # Đọc tệp .asc và tạo SolidData với name từ ánh xạ
+                        data = SolidData.read_asc(asc_path, name=name, dtype=dtype, description=description)
+                        
+                        try:
+                            data.plot(os.path.join(output_dir, "heatmap.png"))
+                        except Exception as e:
+                            print(f"Lỗi khi xử lý {asc_path}: {str(e)}")
+
+                        # Lưu ma trận và metadata vào output_dir
+                        data.save_dok_matrix(output_dir)
+                        
+                        print(f"Đã lưu thành công: {output_dir}")
+                    except Exception as e:
+                        print(f"Lỗi khi xử lý {asc_path}: {str(e)}")
+                        
+    
+    def generate_data_info_json(self, output_file="data_info.json"):
+        """
+        Tạo file JSON ánh xạ filename sang name và dtype cho tất cả các tệp .asc trong thư mục input_root.
+        - output_file: Đường dẫn đến file JSON sẽ được tạo.
+        """
+        data_info = {}
+
+        # Duyệt qua tất cả tệp .asc trong input_root
+        for root, dirs, files in os.walk(self.input_root):
+            for file in files:
+                if file.endswith(".asc"):  # Chỉ xử lý tệp .asc
+                    file_name = os.path.splitext(file)[0]
+                    # Mặc định name và dtype
+                    name = file_name  # Dùng file_name làm name mặc định
+                    dtype = "float"  # Kiểu dữ liệu mặc định
+
+                    # Thêm vào dictionary
+                    data_info[file_name] = {"name": name, "dtype": dtype, "description": "Unknown"}
+
+        # Lưu dictionary vào file JSON
+        with open(output_file, "w") as f:
+            json.dump(data_info, f, indent=4)
+        
+        print(f"File JSON đã được tạo: {output_file}")
+
+
+if __name__ == "__main__":
+    # Khởi tạo đối tượng GenSolidData
+    input_dir = "./data"
+    output_dir = "./solid_data"
+    
+    gen_solid_data = ProcessingSolidData(input_root=input_dir, output_root=output_dir)
+    
+    # Tạo file JSON chứa ánh xạ từ filename sang name và dtype
+    # gen_solid_data.generate_data_info_json("data_info.json")
+    
+    # Đọc bộ ánh xạ từ file JSON
+    gen_solid_data.load_data_info("data_info.json")
+    
+    # Gọi phương thức để xử lý các tệp ASC
+    gen_solid_data.process_asc_files()

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.103.1
+uvicorn==0.23.2
+pydantic==2.3.0
+numpy==1.24.3
+pandas==2.0.3
+scipy==1.10.1
+tqdm==4.66.1
+python-multipart==0.0.6

retrieval_app.py

@@ -0,0 +1,128 @@
+import os
+from tqdm.auto import tqdm
+import pandas as pd
+from solid_data import SolidData
+
+class RetrievalSolidData:
+    def __init__(self, directory):
+        """
+        Khởi tạo đối tượng với thư mục chứa các tệp dữ liệu Solid.
+        - directory: Thư mục chứa dữ liệu Solid.
+        """
+        self.directory = directory
+        self.solid_data_dict = self.load_solid_data_from_directory()
+
+    def load_solid_data_from_directory(self):
+        """
+        Duyệt qua thư mục, tìm các tệp .npz và sử dụng hàm load_dok_matrix
+        để tải và lưu các đối tượng SolidData vào một dictionary.
+        - Trả về: Dictionary với tên dữ liệu là key và đối tượng SolidData là value.
+        """
+        solid_data_dict = {}
+        
+        # Tạo danh sách tất cả file .npz cần xử lý
+        npz_files = []
+        for root, dirs, files in os.walk(self.directory):
+            for file in files:
+                if file.endswith(".npz"):
+                    npz_files.append((root, file))
+        
+        # Dùng tqdm để hiển thị tiến trình
+        for root, file in tqdm(npz_files, desc="Đang tải dữ liệu", unit="file"):
+            file_name = os.path.splitext(file)[0]
+            try:
+                print(f"Đang lấy dữ liệu từ {root}")
+                solid_data_dict[file_name] = SolidData.load_dok_matrix(root)
+            except Exception as e:
+                print(f"\nKhông thể tải dữ liệu từ {file}: {str(e)}")
+        
+        return solid_data_dict
+
+    def get_data(self, lon, lat):
+        """
+        Duyệt qua tất cả các SolidData trong dictionary và trả về giá trị tại vị trí lon, lat.
+        - lon, lat: Tọa độ lon và lat cần tra cứu.
+        - Trả về: Dictionary chứa tên dữ liệu là key và giá trị tại (lon, lat) là value.
+        """
+        result_dict = {'name': [], 'value': []}
+        for file_name, solid_data in self.solid_data_dict.items():
+            try:
+                name = solid_data.name
+                value = solid_data[lon, lat]
+                result_dict['name'].append(name)
+                result_dict['value'].append(value)
+            except ValueError as e:
+                result_dict['name'].append(name)
+                result_dict['value'].append(f"Lỗi: {e}")
+
+        # Chuyển kết quả sang DataFrame
+        df = pd.DataFrame(result_dict)
+        return df
+
+    def get_data_info(self):
+        """
+        Chuyển thông tin từ solid_data_dict thành DataFrame
+        
+        Returns:
+            pd.DataFrame: DataFrame chứa các thuộc tính của các đối tượng SolidData
+        """
+        data = []
+        
+        for file_name, solid_data in self.solid_data_dict.items():
+            data.append({
+                'file_name': file_name,
+                'name': solid_data.name,
+                'rows': solid_data.rows,
+                'columns': solid_data.cols,
+                'x_corner': solid_data.x_corner,
+                'y_corner': solid_data.y_corner,
+                'cell_size': solid_data.cellsize,
+                'description': getattr(solid_data, 'description', 'Unknown')  # Thêm trường description nếu có
+            })
+        
+        # Tạo DataFrame từ danh sách dữ liệu
+        df = pd.DataFrame(data)
+        
+        # Sắp xếp các cột (tuỳ chọn)
+        columns_order = ['name', 'rows', 'columns', 'x_corner', 'y_corner', 'cell_size', 'description']
+        df = df[columns_order]
+        
+        return df
+
+if __name__ == "__main__":
+    solid_data_path = "./solid_data"
+    app = RetrievalSolidData(solid_data_path)
+    
+    while True:
+        print("\n" + "="*50)
+        print("NHẬP TỌA ĐỘ ĐỂ TRA CỨU DỮ LIỆU")
+        print("="*50)
+        
+        try:
+            # Nhập tọa độ từ người dùng
+            lat = float(input("Nhập vĩ độ (latitude): "))
+            lon = float(input("Nhập kinh độ (longitude): "))
+            
+            # Lấy dữ liệu
+            df_data = app.get_data(lon, lat)
+            new_order = ['Elevation', 'SlopesCl1', 'SlopesCl2', 'SlopesCl3', 'SlopesCl4', 'SlopesCl5', 'SlopesCl6', 'SlopesCl7', 'SlopesCl8', 'AspectClN', 'AspectClE', 'AspectClS', 'AspectClW', 'AspectClU', 'WAT', 'NVG', 'URB', 'GRS', 'FOR', 'CULTRF', 'CULTIR', 'CULT', 'sq1', 'sq2', 'sq3', 'sq4', 'sq5', 'sq6', 'sq7', 'LandMask']
+            df_data['name'] = pd.Categorical(df_data['name'], categories=new_order, ordered=True)
+
+            # Sắp xếp theo cột 'name'
+            df_data = df_data.sort_values('name').reset_index(drop=True)
+
+            # Hiển thị kết quả
+            print("\nKẾT QUẢ TRA CỨU:")
+            print("="*50)
+            print(f"Tọa độ: Lat={lat}, Lon={lon}")
+            print("\nGiá trị tại tọa độ:")
+            print(df_data)
+            print(df_data['value'])
+        except ValueError:
+            print("Lỗi: Vui lòng nhập số hợp lệ cho tọa độ!")
+        except KeyboardInterrupt:
+            print("\nKết thúc chương trình...")
+            break
+        except Exception as e:
+            print(f"Lỗi: {str(e)}")
+        

solid_data.py

@@ -0,0 +1,240 @@
+import numpy as np
+from scipy.sparse import dok_matrix, save_npz, load_npz
+from tqdm.auto import tqdm
+import json
+import os
+
+class LonLatMapper:
+    def __init__(self, x_corner, y_corner, cellsize, rows, cols):
+        """
+        Khởi tạo bộ ánh xạ lon-lat sang x-y và ngược lại.
+        - x_corner: Tọa độ x (kinh độ) của góc dưới-trái ô đầu tiên.
+        - y_corner: Tọa độ y (vĩ độ) của góc dưới-trái ô đầu tiên.
+        - cellsize: Kích thước ô lưới (độ hoặc mét).
+        - rows: Số hàng của lưới.
+        - cols: Số cột của lưới.
+        """
+        self.x_corner = x_corner
+        self.y_corner = y_corner
+        self.cellsize = cellsize
+        self.rows = rows
+        self.cols = cols
+    
+    def lonlat2xy(self, lon, lat):
+        """
+        Ánh xạ (lon, lat) sang chỉ số ô lưới (x, y).
+        - lon: Kinh độ (hoặc tọa độ x trong hệ chiếu).
+        - lat: Vĩ độ (hoặc tọa độ y trong hệ chiếu).
+        - Trả về: (x, y) - chỉ số cột và hàng.
+        """
+        x = int(round((lon - self.x_corner) / self.cellsize))
+        y = abs(int(round((lat + self.y_corner) / self.cellsize)))
+        
+        # Kiểm tra giới hạn
+        if not (0 <= x < self.cols and 0 <= y < self.rows):
+            raise ValueError(f"Chỉ số (x={x}, y={y}) ngoài phạm vi lưới ({self.cols}x{self.rows})")
+        
+        return x, y
+    
+    def xy2lonlat(self, x, y):
+        """
+        Ánh xạ chỉ số ô lưới (x, y) sang (lon, lat).
+        - x: Chỉ số cột.
+        - y: Chỉ số hàng.
+        - Trả về: (lon, lat) - kinh độ và vĩ độ.
+        """
+        # Kiểm tra giới hạn
+        if not (0 <= x < self.cols and 0 <= y < self.rows):
+            raise ValueError(f"Chỉ số (x={x}, y={y}) ngoài phạm vi lưới ({self.cols}x{self.rows})")
+        
+        lon = self.x_corner + x * self.cellsize
+        lat = abs(self.y_corner) - y * self.cellsize
+        return lon, lat
+    
+    def lonlat2xy_batch(self, lons, lats):
+        """
+        Ánh xạ hàng loạt (lon, lat) sang (x, y).
+        - lons, lats: Mảng hoặc danh sách kinh độ và vĩ độ.
+        - Trả về: Danh sách (x, y).
+        """
+        lons = np.asarray(lons)
+        lats = np.asarray(lats)
+        x = np.round((lons - self.x_corner) / self.cellsize).astype(int)
+        y = np.abs(np.round((lats + self.y_corner) / self.cellsize)).astype(int)
+        
+        # Kiểm tra giới hạn
+        valid = (x >= 0) & (x < self.cols) & (y >= 0) & (y < self.rows)
+        if not valid.all():
+            raise ValueError("Một số tọa độ ngoài phạm vi lưới")
+        
+        return list(zip(x, y))
+    
+    def xy2lonlat_batch(self, xs, ys):
+        """
+        Ánh xạ hàng loạt (x, y) sang (lon, lat).
+        - xs, ys: Mảng hoặc danh sách chỉ số cột và hàng.
+        - Trả về: Danh sách (lon, lat).
+        """
+        xs = np.asarray(xs)
+        ys = np.asarray(ys)
+        
+        # Kiểm tra giới hạn
+        valid = (xs >= 0) & (xs < self.cols) & (ys >= 0) & (ys < self.rows)
+        if not valid.all():
+            raise ValueError("Một số chỉ số ngoài phạm vi lưới")
+        
+        lons = self.x_corner + xs * self.cellsize
+        lats = abs(self.y_corner) - ys * self.cellsize
+        return list(zip(lons, lats))
+
+
+class SolidData():
+    def __init__(self, M, rows, cols, x_corner, y_corner, cellsize, name, description="Unknown"):
+        self.M, self.rows, self.cols, self.x_corner, self.y_corner, self.cellsize = M, rows, cols, x_corner, y_corner, cellsize
+        self.name = name
+        self.description = description
+        self.mapper = LonLatMapper(self.x_corner, self.y_corner, self.cellsize, self.rows, self.cols)
+
+    def __getitem__(self, key):
+        """
+        Truy cập ma trận thưa hoặc metadata qua toán tử [].
+        - key là tuple (i,j): Trả về giá trị M[i,j] (hoặc 0 nếu không tồn tại). i, j là lon, lat
+        """
+        if isinstance(key, tuple):
+            if self.M is None:
+                raise ValueError("Ma trận chưa được tải. Gọi load_data() trước.")
+            x, y = self.mapper.lonlat2xy(key[0], key[1])
+            return self.M[y, x]  # Trả về giá trị tại (i,j), 0 nếu không có
+        else:
+            raise TypeError("Khóa phải là tuple (lon, lat)")
+    
+    @staticmethod
+    def read_asc(file_path, name, dtype='int', description="Unknown"):
+        # Đọc metadata từ header
+        with open(file_path, "r") as file:
+            cols = int(file.readline().split()[1])
+            rows = int(file.readline().split()[1])
+            x_corner = float(file.readline().split()[1])
+            y_corner = float(file.readline().split()[1])
+            cellsize = float(file.readline().split()[1])
+            nodata_val = float(file.readline().split()[1])  # Giả sử nodata là số
+
+        # Đọc dữ liệu dưới dạng mảng NumPy (bỏ qua 6 dòng header)
+        data = np.loadtxt(file_path, skiprows=6, dtype=np.float64)
+
+        # Xử lý giá trị nodata và chuyển đổi sang ma trận thưa
+        mask = (data != nodata_val)
+        if dtype == 'int':
+            data = data.astype(np.int64)
+        elif dtype == 'float':
+            data = data.astype(np.float64)
+
+        # Tạo ma trận thưa (dok_matrix hoặc lil_matrix)
+        M = dok_matrix((rows, cols), dtype=data.dtype)
+        rows_idx, cols_idx = np.where(mask)
+        M[rows_idx, cols_idx] = data[rows_idx, cols_idx]
+
+        return SolidData(M, rows, cols, x_corner, y_corner, cellsize, name, description)
+            
+    def save_dok_matrix(self, output_dir):
+        """
+        Lưu ma trận dok_matrix và metadata vào thư mục output_dir.
+        - output_dir: Thư mục lưu tệp.
+        - Tệp ma trận: <tên thư mục>.npz.
+        - Tệp metadata: metadata.json.
+        """
+        print("Bắt đầu lưu dữ liệu: ")
+        # Lấy tên thư mục từ output_dir
+        folder_name = os.path.basename(os.path.normpath(output_dir))
+        
+        # Tạo thư mục nếu chưa tồn tại
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Đường dẫn tệp
+        matrix_path = os.path.join(output_dir, f"{folder_name}.npz")
+        metadata_path = os.path.join(output_dir, "metadata.json")
+        
+        # Chuyển dok_matrix sang csr_matrix để lưu
+        M_csr = self.M.tocsr()
+        save_npz(matrix_path, M_csr)
+        
+        # Lưu metadata
+        metadata = {
+            'name'   : self.name,
+            'rows'   : self.rows,
+            'cols'   : self.cols,
+            'x_corner': self.x_corner,
+            'y_corner': self.y_corner,
+            'cellsize': self.cellsize,
+            'description' : self.description
+        }
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f)
+    
+    @staticmethod
+    def load_dok_matrix(input_dir):
+        """
+        Đọc ma trận dok_matrix và metadata từ thư mục input_dir.
+        - input_dir: Thư mục chứa tệp <tên thư mục>.npz và metadata.json.
+        - Trả về: (M, x_corner, y_corner, cellsize)
+        """
+        # Lấy tên thư mục từ input_dir
+        folder_name = os.path.basename(os.path.normpath(input_dir))
+        
+        # Đường dẫn tệp
+        matrix_path = os.path.join(input_dir, f"{folder_name}.npz")
+        metadata_path = os.path.join(input_dir, "metadata.json")
+        
+        # Đọc ma trận
+        M_csr = load_npz(matrix_path)
+        M = M_csr.todok()  # Chuyển lại dok_matrix
+        
+        # Đọc metadata
+        with open(metadata_path, 'r') as f:
+            metadata = json.load(f)
+        
+        rows = metadata['rows']
+        cols = metadata['cols']
+        x_corner = metadata['x_corner']
+        y_corner = metadata['y_corner']
+        cellsize = metadata['cellsize']
+        description = metadata['description']
+        name = metadata['name']
+        data = SolidData(M, rows, cols, x_corner, y_corner, cellsize, name, description)
+        return data
+
+    def sparse2dict(self):
+        sparse_dict = {
+            'lon': [],
+            'lat': [],
+            self.name: [],
+        }
+
+        llmapper = LonLatMapper(self.x_corner, self.y_corner, self.cellsize, self.rows, self.cols)
+        for i in tqdm(self.M.items()):
+            y, x  = i[0]
+            lon, lat = llmapper.xy2lonlat(x, y)
+            sparse_dict['lon'].append(lon)
+            sparse_dict['lat'].append(lat)
+            sparse_dict[self.name].append(i[1])
+        return sparse_dict
+    
+    def plot(self, output_file=None):
+        import matplotlib.pyplot as plt
+        import vaex
+        
+        data_dict = self.sparse2dict()
+        df = vaex.from_dict(data_dict)
+        df.viz.heatmap(df.lon, df.lat, what=vaex.stat.mean(getattr(df, self.name)))
+        if output_file:
+            print("Bắt đầu lưu biểu đồ")
+            folder_name = os.path.dirname(output_file)
+            # Tạo thư mục nếu chưa tồn tại
+            os.makedirs(folder_name, exist_ok=True)
+            plt.savefig(output_file)  # Lưu hình thành tệp
+        else:
+            print("Bắt đầu plot biểu đồ:")
+            plt.show()
+        plt.close()
+
+

solid_data/GloAspectClE_5min/GloAspectClE_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9267959d510d1c7333fb86e5a5316af45e4b680b360d088067be59ecdf73626
+size 3923278

solid_data/GloAspectClE_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "AspectClE", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Aspect class for East-facing slopes, representing the direction of the slope gradient in the Eastward direction."}

solid_data/GloAspectClN_5min/GloAspectClN_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d9d1ac7af0e133533656365849f3f2264a05da4030001fba19db59fe7743494
+size 3892827

solid_data/GloAspectClN_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "AspectClN", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Aspect class for North-facing slopes, representing the direction of the slope gradient towards the north."}

solid_data/GloAspectClS_5min/GloAspectClS_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:882415f2db533c7723bd146dbb0f3255ccb88205460894c2aa7a7e1a9f74143a
+size 3890603

solid_data/GloAspectClS_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "AspectClS", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Aspect class for South-facing slopes, representing the direction of the slope gradient towards the south."}

solid_data/GloAspectClU_5min/GloAspectClU_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15ed47a363aee7a166f180c8255c4d561415beced7fa655392c9f674e70cba95
+size 4319324

solid_data/GloAspectClU_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "AspectClU", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Aspect class for undefined slope aspects where the slope gradient is either undefined or less than a certain threshold."}

solid_data/GloAspectClW_5min/GloAspectClW_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a114071a642a3c9246dcd83a4bdf4ee6ce68db6e4cdf964c63e5719991bd8eb1
+size 3926473

solid_data/GloAspectClW_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "AspectClW", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Aspect class for West-facing slopes, representing the direction of the slope gradient towards the west."}

solid_data/GloElev_5min/GloElev_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3522a95065d3c14222e0b50e1c184bd4a673f549d0a257486dfdcd2760f38b3c
+size 4328335

solid_data/GloElev_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "Elevation", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Median elevation data for each grid cell, measured in meters above sea level."}

solid_data/GloLand_5min/GloLand_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64c27c031dc15e6a3b0860bbd59e77b48298682d0d0c54625837346c326cdd6e
+size 407106

solid_data/GloLand_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "LandMask", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Land mask indicating the fraction of 3 arc-second grid cells that fall into a 5-minute"}

solid_data/GloSlopesCl1_5min/GloSlopesCl1_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb0b1699145748c061e0ffd8d07ba33ef8755374844d3db8be05797108672999
+size 3591579

solid_data/GloSlopesCl1_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "SlopesCl1", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Percentage of grid cells with slope between 0% and 0.5%."}

solid_data/GloSlopesCl2_5min/GloSlopesCl2_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9339c9b3ac6145f057d78f8b4e4e1446b4ffeeac255604090a1aeb2e5fc8c567
+size 4184117

solid_data/GloSlopesCl2_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "SlopesCl2", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Percentage of grid cells with slope between 0.5% and 2%."}

solid_data/GloSlopesCl3_5min/GloSlopesCl3_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:472747752d1f2025cbabe1229c814d522db3bfc1973608531d6eceb6838ff23b
+size 4158399

solid_data/GloSlopesCl3_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "SlopesCl3", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Percentage of grid cells with slope between 2% and 5%."}

solid_data/GloSlopesCl4_5min/GloSlopesCl4_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e1770f8040047f64557c373e12a8557797d131d8c283e2af03d97d6fb5300f1
+size 3776388

solid_data/GloSlopesCl4_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "SlopesCl4", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Percentage of grid cells with slope between 5% and 10%."}

solid_data/GloSlopesCl5_5min/GloSlopesCl5_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:308a95ee1fa2254e45293acde29af429170e311793498aa0a9714090f0fcae65
+size 3069507

solid_data/GloSlopesCl5_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "SlopesCl5", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Percentage of grid cells with slope between 10% and 15%."}

solid_data/GloSlopesCl6_5min/GloSlopesCl6_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae609a37a1ef48772cc1bdf50adfbdf61f2bb1089162ea747b968ea8255afb8a
+size 2762316

solid_data/GloSlopesCl6_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "SlopesCl6", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Percentage of grid cells with slope between 15% and 30%."}

solid_data/GloSlopesCl7_5min/GloSlopesCl7_5min.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33d4c1fb0000dac64a753eac2be9183e315f1db31afda7924a7276c39892bfa3
+size 1890531

solid_data/GloSlopesCl7_5min/metadata.json

@@ -0,0 +1 @@
+{"name": "SlopesCl7", "rows": 2160, "cols": 4320, "x_corner": -180.0, "y_corner": -90.0, "cellsize": 0.0833333333333333, "description": "Percentage of grid cells with slope between 30% and 45%."}