4 Kỹ Thuật Xử Lý Ảnh Thú Vị Sử Dụng JES

JES cho phép bạn tạo bộ lọc hình ảnh của riêng mình chỉ bằng một vài dòng mã.

JES là một môi trường lập trình bao gồm cả khu vực lập trình và dòng lệnh riêng. Bạn có thể sử dụng JES để chỉnh sửa hình ảnh, video và âm thanh.

Có nhiều cách khác nhau để bạn có thể chỉnh sửa ảnh bằng JES. Điều này bao gồm việc thêm bộ lọc thang độ xám hoặc bộ lọc phủ định. Bạn cũng có thể phản chiếu hình ảnh hoặc tăng cường một màu cụ thể.

Cách tạo hình ảnh thang độ xám

Nhiều ứng dụng chỉnh sửa ảnh dễ sử dụng cho phép bạn chỉnh sửa ảnh theo nhiều cách khác nhau. Một trong số này bao gồm thêm bộ lọc thang độ xám. Trong JES, bạn có thể chỉnh sửa hình ảnh để sử dụng bộ lọc thang độ xám bằng cách thay đổi màu của từng pixel để sử dụng màu trắng, xám hoặc đen.

JES sử dụng ngôn ngữ lập trình Jython, ngôn ngữ này rất giống với Python và tuân theo các quy tắc thụt đầu dòng giống nhau. Nếu cần, bạn có thể xem một số lệnh Python hữu ích dành cho người mới bắt đầu để giúp bạn bắt kịp tốc độ.

Tạo một chức năng mới gọi là makeGrayscalePicture():
```
 def makeGrayscalePicture(): 
```
Bên trong chức năng mới, sử dụng chức năng pickAFile() để yêu cầu người dùng chọn một hình ảnh. Sử dụng hàm makePicture() để tạo đối tượng ảnh từ tệp đã chọn:
```
 file = pickAFile() 
pic = makePicture(file) 
```
Sử dụng hàm getPixels() để lấy một mảng gồm tất cả các pixel bên trong hình ảnh đã chọn:
```
 pixels = getPixels(pic) 
```
Sử dụng vòng lặp for để lặp qua từng pixel trong ảnh:
```
 for pixel in pixels: 
```
Bên trong vòng lặp for, lấy giá trị RGB của pixel. Bạn có thể lưu trữ các giá trị màu đỏ, lục và lam của màu thành các biến khác nhau.
```
 r = getRed(pixel)
g = getGreen(pixel)
b = getBlue(pixel) 
```
Tính giá trị trung bình của mỗi màu. Bạn có thể làm điều này bằng cách thêm các giá trị màu đỏ, xanh lá cây và xanh lam rồi chia tổng cho 3:
```
 average = (r + g + b) / 3  
```
Đặt tất cả các giá trị đỏ, lục và lam thành cùng một giá trị. Điều này sẽ làm cho pixel có màu xám.
```
 setRed(pixel, average)
setGreen(pixel, average)
setBlue(pixel, average) 
```
Sau vòng lặp for, hiển thị hình ảnh:
```
 show(pic) 
```
bấm vào Tải chương trình nút, nằm giữa khu vực lập trình và dòng lệnh.
Chạy chức năng bằng khu vực dòng lệnh:
```
 makeGrayscalePicture() 
```
Sử dụng trình khám phá tệp để chọn một hình ảnh. Bấm vào Mở.
Đợi chức năng xử lý xong ảnh. Một cửa sổ mới sẽ mở ra để hiển thị hình ảnh thang độ xám mới.

Cách tạo hình ảnh âm bản

Ảnh âm bản là ảnh trong đó các vùng sáng của ảnh có vẻ tối đi và các phần tối của ảnh có vẻ sáng hơn. Bạn có thể tạo hiệu ứng này bằng cách sửa đổi các giá trị đỏ, lục và lam của mỗi pixel.

Tạo một chức năng mới gọi là makeNegativePicture():
```
 def makeNegativePicture(): 
```
Bên trong chức năng mới, sử dụng chức năng pickAFile() để yêu cầu người dùng chọn một hình ảnh. Sử dụng hàm makePicture() để tạo đối tượng ảnh từ tệp đã chọn:
```
 file = pickAFile() 
pic = makePicture(file) 
```
Sử dụng hàm getPixels() để lấy một mảng gồm tất cả các pixel bên trong hình ảnh đã chọn:
```
 pixels = getPixels(pic) 
```
Sử dụng vòng lặp for để lặp qua từng pixel trong ảnh:
```
 for pixel in pixels: 
```
Bên trong vòng lặp for, lấy các giá trị màu đỏ, lục và lam cho pixel:
```
 r = getRed(pixel)
g = getGreen(pixel)
b = getBlue(pixel) 
```
Để tạo hiệu ứng âm, hãy lấy giá trị ngược lại của màu trên phổ RGB. Ví dụ: nếu giá trị màu đỏ là 100, thì giá trị ngược lại sẽ là 255 – 100, tức là 155.
```
 newRed = 255 - r
newBlue = 255 - g
newGreen = 255 - b 
```
Thay thế màu của pixel bằng các giá trị đỏ, lục và lam mới:
```
 setRed(pixel, newRed)
setBlue(pixel, newBlue)
setGreen(pixel, newGreen) 
```
Sau vòng lặp for, hiển thị hình ảnh:
```
 show(pic) 
```
bấm vào Tải chương trình nút, nằm giữa khu vực lập trình và dòng lệnh.
Chạy hàm makeNegativePicture() từ dòng lệnh:
```
 makeNegativePicture() 
```
Sử dụng trình khám phá tệp để chọn một hình ảnh. Bấm vào Mở.
Một cửa sổ mới sẽ mở ra để hiển thị hình ảnh âm bản.

Cách tăng cường màu cụ thể trong ảnh

Bạn cũng có thể sử dụng JES để tăng cường màu sắc cụ thể của hình ảnh. Ví dụ: bạn có thể nhân đôi giá trị màu đỏ của mỗi pixel để làm cho hình ảnh có nhiều màu đỏ hơn.

Tạo một chức năng mới gọi là alterReds():
```
 def alterReds(): 
```
Bên trong chức năng mới, sử dụng chức năng pickAFile() để yêu cầu người dùng chọn một hình ảnh. Sử dụng hàm makePicture() để tạo đối tượng ảnh từ tệp đã chọn:
```
 file = pickAFile() 
pic = makePicture(file) 
```
Sử dụng hàm getPixels() để lấy một mảng gồm tất cả các pixel bên trong hình ảnh đã chọn:
```
 pixels = getPixels(pic) 
```
Sử dụng vòng lặp for để lặp qua từng pixel trong ảnh:
```
 for pixel in pixels: 
```
Bên trong vòng lặp for, chỉ nhận giá trị màu đỏ của pixel:
```
r = getRed(pixel)
```
Nhân đôi giá trị màu đỏ và lưu trữ nó trong một biến mới:
```
 enhancedRed = r*2  
```
Thay thế giá trị màu đỏ của pixel bằng giá trị mới, được nâng cao. Ví dụ: nếu giá trị RGB ban đầu của pixel là rgb(100, 50, 50), thì giá trị mới sẽ là rgb(200, 50, 50).
```
 setRed(pixel, enhancedRed) 
```
Sau vòng lặp for, hiển thị hình ảnh:
```
 show(pic) 
```
bấm vào Tải chương trình nút, nằm giữa khu vực lập trình và dòng lệnh.
Chạy chức năng bằng khu vực dòng lệnh:
```
 alterReds() 
```
Sử dụng trình khám phá tệp để chọn một hình ảnh. Bấm vào Mở.
Một cửa sổ mới sẽ mở ra để hiển thị hình ảnh đã chỉnh sửa.

Cách phản chiếu hình ảnh

Để phản chiếu hình ảnh, mọi pixel ở bên trái của hình ảnh phải khớp chính xác với pixel đối diện ở bên phải.

Bạn có thể làm điều này bằng cách tạo một hình ảnh trống mới với nền trắng. Sau đó, bạn có thể sao chép từng pixel để tạo hình ảnh phản chiếu mới.

Tạo một hàm mới gọi là mirror():
```
 def mirror(): 
```
Bên trong chức năng mới, sử dụng chức năng pickAFile() để yêu cầu người dùng chọn một hình ảnh. Sử dụng hàm makePicture() để tạo đối tượng ảnh từ tệp đã chọn:
```
 file = pickAFile() 
pic = makePicture(file)  
```
Lấy chiều cao và chiều rộng của hình ảnh đã chọn:
```
 width = getWidth(pic)
height = getHeight(pic) 
```
Sử dụng hàm makeEmptyPicture() để tạo một hình ảnh trống. Ảnh trống là ảnh có nền trắng. Nhân đôi chiều rộng để bạn có thể vừa với hình ảnh gốc ở bên trái và hình ảnh đã lật ở bên phải:
```
 mirroredPic = makeEmptyPicture(width*2, height) 
```
Tạo vòng lặp for để lặp qua từng tọa độ x và y của ảnh gốc. Bên trong vòng lặp for, lấy pixel được lưu trữ tại vị trí đó:
```
 for x in range(0, width):
    for y in range(0, height):
        originalPix = getPixel(pic, x, y) 
```
Vẫn bên trong vòng lặp for, lấy pixel trong hình ảnh trống mới ở cùng vị trí x và y. Đây sẽ là phía bên trái của hình ảnh phản chiếu:
```
 leftMirrorPixel = getPixel(mirroredPic, x, y)  
```
Sao chép màu của pixel gốc sang pixel ở bên trái của hình ảnh mới:
```
 setColor(leftMirrorPixel, getColor(originalPix)) 
```
Làm điều tương tự cho phía bên phải. Tọa độ y sẽ giống nhau. Vì tọa độ x sẽ ở phía bên phải, hãy trừ tọa độ x khỏi toàn bộ chiều rộng của ảnh được nhân đôi mới:
```
 rightMirrorPixel = getPixel(mirroredPic, (width*2)-x-1, y) 
```
Sao chép màu của pixel gốc sang pixel ở bên phải của hình ảnh mới:
```
 setColor(rightMirrorPixel, getColor(originalPix)) 
```
Sau vòng lặp for, hiển thị hình ảnh:
```
 show(mirroredPic) 
```
bấm vào Tải chương trình nút, nằm giữa khu vực lập trình và dòng lệnh.
Chạy hàm mirror() từ dòng lệnh:
```
 mirror() 
```
Sử dụng trình khám phá tệp để chọn một hình ảnh. Bấm vào Mở.
Một cửa sổ mới sẽ mở ra để hiển thị hình ảnh phản chiếu.

Chỉnh sửa hình ảnh bằng JES

Bây giờ hy vọng bạn đã hiểu cách chỉnh sửa ảnh trong JES bằng nhiều kỹ thuật khác nhau. Đây không phải là những kỹ thuật duy nhất bạn có thể áp dụng cho ảnh, vì vậy bạn có thể thử nghiệm thêm với các khả năng khác trong JES.

Nếu bạn muốn cải thiện kỹ năng Python của mình, thì các dự án ngắn và thú vị là một cách tuyệt vời để hiểu các khái niệm chính của Python.