OpenCV - คู่มือฉบับย่อ

OpenCV เป็นไลบรารีข้ามแพลตฟอร์มซึ่งเราสามารถพัฒนาแบบเรียลไทม์ computer vision applications. ส่วนใหญ่มุ่งเน้นไปที่การประมวลผลภาพการจับภาพวิดีโอและการวิเคราะห์รวมถึงคุณสมบัติต่างๆเช่นการตรวจจับใบหน้าและการตรวจจับวัตถุ

เริ่มต้นบทด้วยการกำหนดคำว่า "Computer Vision"

วิสัยทัศน์คอมพิวเตอร์

Computer Vision สามารถกำหนดเป็นระเบียบวินัยที่อธิบายวิธีสร้างใหม่ขัดจังหวะและทำความเข้าใจฉาก 3 มิติจากภาพ 2 มิติในแง่ของคุณสมบัติของโครงสร้างที่มีอยู่ในฉาก เกี่ยวข้องกับการสร้างแบบจำลองและจำลองวิสัยทัศน์ของมนุษย์โดยใช้ซอฟต์แวร์และฮาร์ดแวร์คอมพิวเตอร์

Computer Vision ทับซ้อนกันอย่างมีนัยสำคัญกับฟิลด์ต่อไปนี้ -

  • Image Processing - เน้นการปรับแต่งภาพ

  • Pattern Recognition - อธิบายเทคนิคต่างๆในการจำแนกรูปแบบ

  • Photogrammetry - เกี่ยวข้องกับการได้รับการวัดที่แม่นยำจากภาพ

Computer Vision Vs Image Processing

Image processingเกี่ยวข้องกับการแปลงภาพเป็นภาพ อินพุตและเอาต์พุตของการประมวลผลภาพมีทั้งภาพ

Computer visionคือการสร้างคำอธิบายที่ชัดเจนและมีความหมายของวัตถุทางกายภาพจากรูปภาพ ผลลัพธ์ของการมองเห็นด้วยคอมพิวเตอร์คือคำอธิบายหรือการตีความโครงสร้างในฉาก 3 มิติ

การใช้งาน Computer Vision

ที่นี่เราได้ระบุโดเมนหลักบางส่วนที่มีการใช้งาน Computer Vision อย่างมาก

การประยุกต์ใช้หุ่นยนต์

  • การแปลเป็นภาษาท้องถิ่น - กำหนดตำแหน่งหุ่นยนต์โดยอัตโนมัติ

  • Navigation

  • หลีกเลี่ยงอุปสรรค

  • การประกอบ (การเจาะรูการเชื่อมการทาสี)

  • การจัดการ (เช่นหุ่นยนต์บังคับ PUMA)

  • Human Robot Interaction (HRI) - หุ่นยนต์อัจฉริยะเพื่อโต้ตอบและให้บริการผู้คน

ใบสมัครยา

  • การจำแนกประเภทและการตรวจหา (เช่นการจำแนกรอยโรคหรือเซลล์และการตรวจหาเนื้องอก)
  • การแบ่งส่วน 2D / 3D
  • การสร้างอวัยวะใหม่ของมนุษย์ 3 มิติ (MRI หรืออัลตราซาวนด์)
  • การผ่าตัดด้วยหุ่นยนต์นำทางด้วยสายตา

แอปพลิเคชันระบบอัตโนมัติทางอุตสาหกรรม

  • การตรวจสอบอุตสาหกรรม (การตรวจจับข้อบกพร่อง)
  • Assembly
  • การอ่านฉลากบาร์โค้ดและแพ็คเกจ
  • การจัดเรียงวัตถุ
  • ความเข้าใจเอกสาร (เช่น OCR)

แอปพลิเคชันความปลอดภัย

  • ไบโอเมตริกซ์ (ม่านตาพิมพ์ลายนิ้วมือจดจำใบหน้า)

  • การเฝ้าระวัง - ตรวจจับกิจกรรมหรือพฤติกรรมที่น่าสงสัยบางอย่าง

ใบสมัครการขนส่ง

  • ยานพาหนะที่เป็นอิสระ
  • ความปลอดภัยเช่นการตรวจสอบความระมัดระวังของผู้ขับขี่

คุณสมบัติของ OpenCV Library

เมื่อใช้ไลบรารี OpenCV คุณสามารถ -

  • อ่านและเขียนภาพ

  • จับภาพและบันทึกวิดีโอ

  • ประมวลผลภาพ (กรอง, แปลงร่าง)

  • ทำการตรวจหาคุณสมบัติ

  • ตรวจจับวัตถุที่เฉพาะเจาะจงเช่นใบหน้าดวงตารถยนต์ในวิดีโอหรือรูปภาพ

  • วิเคราะห์วิดีโอเช่นประเมินการเคลื่อนไหวในวิดีโอลบพื้นหลังและติดตามวัตถุในวิดีโอ

OpenCV เดิมได้รับการพัฒนาใน C ++ นอกจากนี้ยังมีการรวม Python และ Java OpenCV ทำงานบนระบบปฏิบัติการต่างๆเช่น windows, Linux, OSx, FreeBSD, Net BSD, Open BSD เป็นต้น

บทช่วยสอนนี้อธิบายแนวคิดของ OpenCV พร้อมตัวอย่างการใช้การผูก Java

โมดูลไลบรารี OpenCV

ต่อไปนี้เป็นโมดูลไลบรารีหลักของไลบรารี OpenCV

ฟังก์ชันหลัก

โมดูลนี้ครอบคลุมโครงสร้างข้อมูลพื้นฐานเช่น Scalar, Point, Range ฯลฯ ที่ใช้ในการสร้างแอปพลิเคชัน OpenCV นอกจากนี้ยังรวมถึงอาร์เรย์หลายมิติด้วยMatซึ่งใช้ในการจัดเก็บภาพ ในไลบรารี Java ของ OpenCV โมดูลนี้รวมอยู่ในแพ็คเกจที่มีชื่อorg.opencv.core.

การประมวลผลภาพ

โมดูลนี้ครอบคลุมการดำเนินการประมวลผลภาพต่างๆเช่นการกรองภาพการแปลงภาพเชิงเรขาคณิตการแปลงพื้นที่สีฮิสโตแกรมเป็นต้นในไลบรารี Java ของ OpenCV โมดูลนี้รวมเป็นแพ็คเกจที่มีชื่อ org.opencv.imgproc.

วิดีโอ

โมดูลนี้ครอบคลุมแนวคิดการวิเคราะห์วิดีโอเช่นการประมาณค่าการเคลื่อนไหวการลบพื้นหลังและการติดตามวัตถุ ในไลบรารี Java ของ OpenCV โมดูลนี้รวมอยู่ในแพ็คเกจที่มีชื่อorg.opencv.video.

วิดีโอ I / O

โมดูลนี้อธิบายเกี่ยวกับการจับภาพวิดีโอและตัวแปลงสัญญาณวิดีโอโดยใช้ไลบรารี OpenCV ในไลบรารี Java ของ OpenCV โมดูลนี้รวมอยู่ในแพ็คเกจที่มีชื่อorg.opencv.videoio.

calib3d

โมดูลนี้ประกอบด้วยอัลกอริทึมเกี่ยวกับอัลกอริธึมรูปเรขาคณิตหลายมุมมองพื้นฐานการปรับเทียบกล้องเดี่ยวและสเตอริโอการประมาณค่าวัตถุการรองรับสเตอริโอและองค์ประกอบของการสร้าง 3D ในไลบรารี Java ของ OpenCV โมดูลนี้รวมอยู่ในแพ็คเกจที่มีชื่อorg.opencv.calib3d.

คุณสมบัติ 2d

โมดูลนี้รวมถึงแนวคิดของการตรวจจับคุณลักษณะและคำอธิบาย ในไลบรารี Java ของ OpenCV โมดูลนี้รวมอยู่ในแพ็คเกจที่มีชื่อorg.opencv.features2d.

Objdetect

โมดูลนี้รวมถึงการตรวจจับวัตถุและอินสแตนซ์ของคลาสที่กำหนดไว้ล่วงหน้าเช่นใบหน้าดวงตาแก้วคนรถยนต์ ฯลฯ ในไลบรารี Java ของ OpenCV โมดูลนี้จะรวมเป็นแพ็คเกจที่มีชื่อ org.opencv.objdetect.

ไฮกุย

นี่คืออินเทอร์เฟซที่ใช้งานง่ายพร้อมความสามารถ UI ที่เรียบง่าย ในไลบรารี Java ของ OpenCV คุณสมบัติของโมดูลนี้รวมอยู่ในแพ็คเกจสองแพ็คเกจที่แตกต่างกันคือorg.opencv.imgcodecs และ org.opencv.videoio.

ประวัติโดยย่อของ OpenCV

OpenCV เป็นโครงการริเริ่มการวิจัยของ Intel เพื่อให้คำแนะนำแอปพลิเคชันที่ใช้ CPU มาก เปิดตัวอย่างเป็นทางการในปี 2542

  • ในปี 2549 มีการเปิดตัว OpenCV 1.0 เวอร์ชันหลักรุ่นแรก
  • ในเดือนตุลาคม พ.ศ. 2552 OpenCV 2 เวอร์ชันหลักที่สองได้รับการเผยแพร่
  • ในเดือนสิงหาคม 2555 OpenCV ถูกยึดครองโดยองค์กรไม่แสวงหาผลกำไร OpenCV.org

ในบทนี้คุณจะได้เรียนรู้วิธีการติดตั้ง OpenCV และตั้งค่าสภาพแวดล้อมในระบบของคุณ

การติดตั้ง OpenCV

ก่อนอื่นคุณต้องดาวน์โหลด OpenCV ลงในระบบของคุณ ทำตามขั้นตอนที่ระบุด้านล่าง

Step 1 - เปิดหน้าแรกของ OpenCV โดยคลิกที่ลิงค์ต่อไปนี้: http://opencv.org/ เมื่อคลิกคุณจะเห็นหน้าแรกดังที่แสดงด้านล่าง

Step 2 - ตอนนี้คลิกที่ไฟล์ Downloadsลิงก์ที่ไฮไลต์ในภาพหน้าจอด้านบน เมื่อคลิกคุณจะเข้าสู่หน้าดาวน์โหลดของ OpenCV

Step 3 - เมื่อคลิกลิงก์ที่ไฮไลต์ในภาพหน้าจอด้านบนไฟล์ชื่อ opencv-3.1.0.exeจะถูกดาวน์โหลด แตกไฟล์นี้เพื่อสร้างโฟลเดอร์opencv ในระบบของคุณดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 4 - เปิดโฟลเดอร์ OpenCVbuildjava. ที่นี่คุณจะพบไฟล์ jar ของ OpenCV ที่ชื่อopencv-310.jar. บันทึกไฟล์นี้ในโฟลเดอร์แยกต่างหากเพื่อใช้งานต่อไป

การติดตั้ง Eclipse

หลังจากดาวน์โหลดไฟล์ JAR ที่ต้องการคุณต้องฝังไฟล์ JAR เหล่านี้เข้ากับสภาวะแวดล้อม Eclipse ของคุณ คุณสามารถทำได้โดยการตั้งค่า Build Path เป็นไฟล์ JAR เหล่านี้และโดยใช้pom.xml.

การตั้งค่า Build Path

ต่อไปนี้เป็นขั้นตอนในการตั้งค่า OpenCV ใน Eclipse -

Step 1- ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง Eclipse ในระบบของคุณ หากไม่มีให้ดาวน์โหลดและติดตั้ง Eclipse ในระบบของคุณ

Step 2 - เปิด Eclipse คลิกที่ไฟล์ใหม่และเปิดโครงการใหม่ดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 3 - ในการเลือกโครงการคุณจะได้รับไฟล์ New Projectตัวช่วย ในวิซาร์ดนี้เลือกโปรเจ็กต์ Java และดำเนินการต่อโดยคลิกที่ไฟล์Next ดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 4 - ในการดำเนินการต่อคุณจะถูกนำไปที่ไฟล์ New Java Project wizard. สร้างโครงการใหม่แล้วคลิกNextดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 5- หลังจากสร้างโปรเจ็กต์ใหม่แล้วให้คลิกขวาที่มัน เลือกBuild Path แล้วคลิก Configure Build Path… ดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 6 - เมื่อคลิกที่ไฟล์ Build Path คุณจะถูกนำไปที่ไฟล์ Java Build Path wizard. คลิกAdd External JARs ดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 7 - เลือกเส้นทางที่คุณบันทึกไฟล์ opencv-310.jar.

Step 8 - เมื่อคลิกที่ไฟล์ Open ในภาพหน้าจอด้านบนไฟล์เหล่านั้นจะถูกเพิ่มลงในห้องสมุดของคุณ

Step 9 - เมื่อคลิก OKคุณจะเพิ่มไฟล์ JAR ที่ต้องการลงในโปรเจ็กต์ปัจจุบันได้สำเร็จและคุณสามารถตรวจสอบไลบรารีที่เพิ่มเหล่านี้ได้โดยการขยายไลบรารีอ้างอิง

การตั้งค่าเส้นทางสำหรับไลบรารีดั้งเดิม

นอกจากไฟล์ JAR แล้วคุณต้องตั้งค่าพา ธ สำหรับไลบรารีเนทีฟ (ไฟล์ DLL) ของ OpenCV

Location of DLL files - เปิดโฟลเดอร์การติดตั้งของ OpenCV และไปที่โฟลเดอร์ย่อย buildjava. ที่นี่คุณจะพบสองโฟลเดอร์x64 (64 บิต) และ x86 (32 บิต) ซึ่งมีไฟล์ dll ไฟล์ของ OpenCV

เปิดโฟลเดอร์ที่เหมาะสมกับระบบปฏิบัติการของคุณจากนั้นคุณจะเห็นไฟล์ dll ดังที่แสดงในภาพหน้าจอต่อไปนี้

ตอนนี้กำหนดเส้นทางสำหรับไฟล์นี้ด้วยโดยทำตามขั้นตอนด้านล่าง -

Step 1- เปิดหน้าต่าง JavaBuildPath อีกครั้ง ที่นี่คุณสามารถสังเกตไฟล์ JAR ที่เพิ่มเข้ามาและไฟล์JRE System Library.

Step 2 - เมื่อขยายคุณจะได้รับไลบรารีระบบและ Native library locationดังที่ไฮไลต์ไว้ในภาพหน้าจอต่อไปนี้

Step 3 - ดับเบิลคลิกที่ไฟล์ Native library location. ที่นี่คุณสามารถดูไฟล์Native Library Folder Configuration window ดังแสดงด้านล่าง

คลิกปุ่มที่นี่ External Folder… และเลือกตำแหน่งของไฟล์ dll ไฟล์ในระบบของคุณ

ในการถ่ายภาพเราใช้อุปกรณ์เช่นกล้องถ่ายรูปและเครื่องสแกน อุปกรณ์เหล่านี้บันทึกค่าตัวเลขของภาพ (เช่นค่าพิกเซล) OpenCV เป็นไลบรารีที่ประมวลผลภาพดิจิทัลดังนั้นเราจึงจำเป็นต้องจัดเก็บภาพเหล่านี้เพื่อประมวลผล

Matคลาสของไลบรารี OpenCV ใช้เพื่อเก็บค่าของรูปภาพ มันแสดงถึงอาร์เรย์ n มิติและใช้ในการจัดเก็บข้อมูลภาพของภาพระดับสีเทาหรือสีปริมาตรของว็อกเซลฟิลด์เวกเตอร์เมฆจุดเทนเซอร์ฮิสโทแกรม ฯลฯ

คลาสนี้ประกอบด้วยข้อมูลสองส่วน: ส่วน header และก pointer

  • Header - มีข้อมูลเช่นขนาดวิธีที่ใช้ในการจัดเก็บและที่อยู่ของเมทริกซ์ (ขนาดคงที่)

  • Pointer - เก็บค่าพิกเซลของภาพ (เก็บไว้ที่แตกต่างกัน)

ชั้นเสื่อ

ไลบรารี OpenCV Java จัดเตรียมคลาสนี้ด้วยชื่อเดียวกัน (Mat) ภายในแพ็คเกจ org.opencv.core.

ตัวสร้าง

คลาส Mat ของไลบรารี OpenCV Java มีตัวสร้างหลายแบบซึ่งคุณสามารถสร้างวัตถุ Mat

ส. เลขที่ ตัวสร้างและคำอธิบาย
1

Mat()

นี่คือตัวสร้างเริ่มต้นที่ไม่มีพารามิเตอร์ในกรณีส่วนใหญ่ เราใช้สิ่งนี้เพื่อตัวสร้างเพื่อสร้างเมทริกซ์ว่างและส่งต่อไปยังเมธอด OpenCV อื่น ๆ

2

Mat(int rows, int cols, int type)

ตัวสร้างนี้ยอมรับสามพารามิเตอร์ของประเภทจำนวนเต็มซึ่งแสดงถึงจำนวนแถวและคอลัมน์ในอาร์เรย์ 2 มิติและประเภทของอาร์เรย์ (ซึ่งจะใช้ในการจัดเก็บข้อมูล)

3

Mat(int rows, int cols, int type, Scalar s)

รวมถึงพารามิเตอร์ของตัวก่อนหน้านี้ตัวสร้างนี้ยังยอมรับอ็อบเจ็กต์ของคลาส Scalar เป็นพารามิเตอร์

4

Mat(Size size, int type)

คอนสตรัคเตอร์นี้ยอมรับสองพารามิเตอร์คืออ็อบเจ็กต์ที่แสดงขนาดของเมทริกซ์และจำนวนเต็มแทนชนิดของอาร์เรย์ที่ใช้ในการจัดเก็บข้อมูล

5

Mat(Size size, int type, Scalar s)

รวมถึงพารามิเตอร์ของตัวก่อนหน้านี้ตัวสร้างนี้ยังยอมรับอ็อบเจ็กต์ของคลาส Scalar เป็นพารามิเตอร์

6

Mat(long addr)

7

Mat(Mat m, Range rowRange)

ตัวสร้างนี้ยอมรับอ็อบเจ็กต์ของเมทริกซ์อื่นและอ็อบเจ็กต์ของคลาส Range ที่แสดงช่วงของแถวที่จะใช้เพื่อสร้างเมทริกซ์ใหม่

8

Mat(Mat m, Range rowRange, Range colRange)

รวมถึงพารามิเตอร์ของพารามิเตอร์ก่อนหน้านี้ตัวสร้างนี้ยังยอมรับอ็อบเจ็กต์ของคลาสอีกด้วย ช่วงที่แสดงช่วงคอลัมน์

9

Mat(Mat m, Rect roi)

ตัวสร้างนี้ยอมรับสองอ็อบเจ็กต์หนึ่งแทนเมทริกซ์อื่นและอีกอันแสดงถึง Rอีเจียน OInterest.

Note -

  • ประเภทอาร์เรย์ ใช้ CV_8UC1, ... , CV_64FC4 เพื่อสร้างเมทริกซ์ 1-4 แชนเนลหรือ CV_8UC (n), ... , CV_64FC (n) เพื่อสร้างเมทริกซ์แบบหลายแชนเนล (สูงสุด CV_CN_MAX แชนเนล)

  • ประเภทของเมทริกซ์แสดงโดยฟิลด์ต่างๆของคลาส CvType ซึ่งเป็นของแพ็คเกจ org.opencv.core.

วิธีการและคำอธิบาย

ต่อไปนี้เป็นวิธีการบางส่วนที่จัดเตรียมโดยคลาส Mat

ส. เลขที่ วิธีการและคำอธิบาย
1

Mat col(int x)

วิธีนี้ยอมรับพารามิเตอร์จำนวนเต็มแทนดัชนีของคอลัมน์และดึงข้อมูลและส่งคืนคอลัมน์นั้น

2

Mat row(int y)

วิธีนี้ยอมรับพารามิเตอร์จำนวนเต็มแทนดัชนีของแถวและดึงข้อมูลและส่งคืนแถวนั้น

3

int cols()

วิธีนี้ส่งกลับจำนวนคอลัมน์ในเมทริกซ์

4

int rows()

วิธีนี้จะส่งคืนจำนวนแถวในเมทริกซ์

5

Mat setTo(Mat value)

วิธีนี้ยอมรับวัตถุของ Mat พิมพ์และตั้งค่าองค์ประกอบอาร์เรย์เป็นค่าที่ระบุ

6

Mat setTo(Scalar s)

วิธีนี้ยอมรับวัตถุของ Scalar พิมพ์และตั้งค่าองค์ประกอบอาร์เรย์เป็นค่าที่ระบุ

การสร้างและการแสดงเมทริกซ์

ในส่วนนี้เราจะพูดถึงตัวอย่าง OpenCV แรกของเรา เราจะดูวิธีการสร้างและแสดงเมทริกซ์ OpenCV อย่างง่าย

ด้านล่างนี้เป็นขั้นตอนที่ต้องปฏิบัติตามเพื่อสร้างและแสดงเมทริกซ์ใน OpenCV

ขั้นตอนที่ 1: โหลดไลบรารีเนทีฟ OpenCV

ในขณะที่เขียนโค้ด Java โดยใช้ไลบรารี OpenCV ขั้นตอนแรกที่คุณต้องทำคือโหลดไลบรารีดั้งเดิมของ OpenCV โดยใช้ loadLibrary(). โหลดไลบรารีเนทีฟ OpenCV ดังที่แสดงด้านล่าง

//Loading the core library 
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

ขั้นตอนที่ 2: สร้างคลาส Mat

สร้างอินสแตนซ์คลาส Mat โดยใช้ฟังก์ชันใด ๆ ที่กล่าวถึงในบทก่อนหน้านี้

//Creating a matrix 
Mat matrix = new Mat(5, 5, CvType.CV_8UC1, new Scalar(0));

ขั้นตอนที่ 3: เติมเมทริกซ์โดยใช้วิธีการ

คุณสามารถดึงข้อมูลแถว / คอลัมน์เฉพาะของเมทริกซ์ได้โดยส่งค่าดัชนีไปยังเมธอด row()/col().

และคุณสามารถตั้งค่าเป็นค่าเหล่านี้โดยใช้ตัวแปรใด ๆ ของ setTo() วิธีการ

//Retrieving the row with index 0 
Mat row0 = matrix.row(0); 
     
//setting values of all elements in the row with index 0 
row0.setTo(new Scalar(1)); 
     
//Retrieving the row with index 3 
Mat col3 = matrix.col(3);  
     
//setting values of all elements in the row with index 3 
col3.setTo(new Scalar(3));

Example

คุณสามารถใช้โค้ดโปรแกรมต่อไปนี้เพื่อสร้างและแสดงเมทริกซ์อย่างง่ายใน Java โดยใช้ไลบรารี OpenCV

import org.opencv.core.Core; 
import org.opencv.core.Mat;  
import org.opencv.core.CvType;  
import org.opencv.core.Scalar;   

class DisplayingMatrix { 
   public static void main(String[] args) {     
      //Loading the core library 
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);     

      //Creating a matrix 
      Mat matrix = new Mat(5, 5, CvType.CV_8UC1, new Scalar(0));  

      //Retrieving the row with index 0 
      Mat row0 = matrix.row(0);

      //setting values of all elements in the row with index 0 
      row0.setTo(new Scalar(1)); 

      //Retrieving the row with index 3 
      Mat col3 = matrix.col(3);  

      //setting values of all elements in the row with index 3 
      col3.setTo(new Scalar(3)); 

      //Printing the matrix 
      System.out.println("OpenCV Mat data:\n" + matrix.dump()); 
   } 
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

OpenCV Mat data: 
[  1,   1,   1,   3,   1; 
   0,   0,   0,   3,   0; 
   0,   0,   0,   3,   0; 
   0,   0,   0,   3,   0; 
   0,   0,   0,   3,   0]

กำลังโหลดรูปภาพโดยใช้ JavaSE API

BufferedImage คลาสของ java.awt.image.BufferedImage แพ็คเกจใช้ในการจัดเก็บรูปภาพและไฟล์ ImageIO คลาสของแพ็คเกจ import javax.imageio มีวิธีการอ่านและเขียนรูปภาพ

Example

คุณสามารถใช้โค้ดโปรแกรมต่อไปนี้เพื่อโหลดและบันทึกรูปภาพโดยใช้ไลบรารี JavaSE

import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 
import javax.imageio.ImageIO;
  
public class LoadingImage_JSE_library {
   public static void main( String[] args ) throws IOException {
      //Input File 
      File input = new File("C:/EXAMPLES/OpenCV/sample.jpg");
          
      //Reading the image 
      BufferedImage image = ImageIO.read(input);
      
      //Saving the image with a different name
      File ouptut = new File("C:/OpenCV/sample.jpg");
      ImageIO.write(image, "jpg", ouptut);
         
      System.out.println("image Saved");
   } 
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

image Saved

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่บันทึกได้ดังนี้ -

Imgcodecs คลาสของแพ็คเกจ org.opencv.imgcodecsมีวิธีการอ่านและเขียนภาพ เมื่อใช้ OpenCV คุณสามารถอ่านภาพและจัดเก็บไว้ในเมทริกซ์ (ทำการแปลงบนเมทริกซ์หากจำเป็น) หลังจากนั้นคุณสามารถเขียนเมทริกซ์ที่ประมวลผลไปยังไฟล์ได้

read() วิธีการของ Imgcodecsคลาสใช้ในการอ่านรูปภาพโดยใช้ OpenCV ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

imread(filename)

มันยอมรับข้อโต้แย้ง (filename)ซึ่งเป็นตัวแปรประเภท String ที่แสดงเส้นทางของไฟล์ที่จะอ่าน

ด้านล่างนี้เป็นขั้นตอนในการอ่านภาพใน Java โดยใช้ไลบรารี OpenCV

ขั้นตอนที่ 1: โหลดไลบรารีเนทีฟ OpenCV

โหลดไลบรารีเนทีฟ OpenCV โดยใช้ไฟล์ load() วิธีการดังที่แสดงด้านล่าง

//Loading the core library 
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

ขั้นตอนที่ 2: สร้างอินสแตนซ์คลาส Imgcodecs

เริ่มต้นไฟล์ Imgcodecs ชั้นเรียน

//Instantiating the Imgcodecs class 
Imgcodecs imageCodecs = new Imgcodecs();

ขั้นตอนที่ 3: การอ่านภาพ

อ่านภาพโดยใช้วิธี imread(). วิธีนี้ยอมรับอาร์กิวเมนต์สตริงที่แสดงเส้นทางของรูปภาพและส่งคืนรูปภาพที่อ่านเป็นMat วัตถุ.

//Reading the Image from the file  
Mat matrix = imageCodecs.imread(Path of the image);

ตัวอย่าง

รหัสโปรแกรมต่อไปนี้แสดงให้เห็นว่าคุณทำได้อย่างไร read an image ใช้ไลบรารี OpenCV

import org.opencv.core.Core; 
import org.opencv.core.Mat;  
import org.opencv.imgcodecs.Imgcodecs;
 
public class ReadingImages {
   public static void main(String args[]) { 
      //Loading the OpenCV core library  
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME ); 
     
      //Instantiating the Imagecodecs class 
      Imgcodecs imageCodecs = new Imgcodecs(); 
     
      //Reading the Image from the file  
      String file ="C:/EXAMPLES/OpenCV/sample.jpg"; 
      Mat matrix = imageCodecs.imread(file); 
     
      System.out.println("Image Loaded");     
   } 
}

ในการรันโปรแกรมข้างต้น OpenCV จะโหลดภาพที่ระบุและแสดงผลลัพธ์ต่อไปนี้ -

Image Loaded

write() วิธีการของ Imgcodecsคลาสใช้ในการเขียนภาพโดยใช้ OpenCV ในการเขียนภาพให้ทำซ้ำสามขั้นตอนแรกจากตัวอย่างก่อนหน้านี้

ในการเขียนภาพคุณต้องเรียกใช้ไฟล์ imwrite() วิธีการของ Imgcodecs ชั้นเรียน

ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

imwrite(filename, mat)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • filename - ก String ตัวแปรที่แสดงเส้นทางที่จะบันทึกไฟล์

  • mat - ก Mat วัตถุที่เป็นตัวแทนของภาพที่จะเขียน

ตัวอย่าง

โปรแกรมต่อไปนี้เป็นตัวอย่างของ write an image โดยใช้โปรแกรม Java โดยใช้ไลบรารี OpenCV

import org.opencv.core.Core; 
import org.opencv.core.Mat; 
import org.opencv.imgcodecs.Imgcodecs;
 
public class WritingImages {  
   public static void main(String args[]) { 
      //Loading the OpenCV core library  
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME); 
      
      //Instantiating the imagecodecs class 
      Imgcodecs imageCodecs = new Imgcodecs(); 

      //Reading the Image from the file and storing it in to a Matrix object 
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";   
      Mat matrix = imageCodecs.imread(file); 

      System.out.println("Image Loaded ..........");
      String file2 = "C:/EXAMPLES/OpenCV/sample_resaved.jpg"; 

      //Writing the image 
      imageCodecs.imwrite(file2, matrix); 
      System.out.println("Image Saved ............"); 
   } 
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Loaded .......... 
Image Saved ...........

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่บันทึกไว้ดังที่แสดงด้านล่าง -

ในบทก่อนหน้านี้เราได้กล่าวถึงวิธีการอ่านและบันทึกภาพโดยใช้ไลบรารี OpenCV Java นอกจากนี้เรายังสามารถแสดงรูปภาพที่โหลดในหน้าต่างแยกต่างหากโดยใช้ไลบรารี GUI เช่น AWT / Swings และ JavaFX

การแปลง Mat เป็น Buffered Image

ในการอ่านภาพเราใช้วิธีการ imread(). วิธีนี้ส่งคืนรูปภาพที่อ่านในรูปแบบMatrix. แต่หากต้องการใช้รูปภาพนี้กับไลบรารี GUI (AWT / Swings และ JavaFX) ควรแปลงเป็นวัตถุของคลาสBufferedImage ของแพ็คเกจ java.awt.image.BufferedImage.

ต่อไปนี้เป็นขั้นตอนในการแปลงไฟล์ Mat วัตถุของ OpenCV ถึง BufferedImage วัตถุ.

ขั้นตอนที่ 1: เข้ารหัส Mat เป็น MatOfByte

ก่อนอื่นคุณต้องแปลงเมทริกซ์เป็นเมทริกซ์ของไบต์ คุณสามารถทำได้โดยใช้วิธีimencode() ของชั้นเรียน Imgcodecs. ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

imencode(ext, image, matOfByte);

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • Ext - พารามิเตอร์สตริงที่ระบุรูปแบบภาพ (.jpg, .png ฯลฯ )

  • image - วัตถุ Mat ของภาพ

  • matOfByte - วัตถุว่างของคลาส MatOfByte

เข้ารหัสภาพโดยใช้วิธีนี้ดังที่แสดงด้านล่าง

//Reading the image 
Mat image = Imgcodecs.imread(file);

//instantiating an empty MatOfByte class 
MatOfByte matOfByte = new MatOfByte();

//Converting the Mat object to MatOfByte 
Imgcodecs.imencode(".jpg", image, matOfByte);

ขั้นตอนที่ 2: แปลงวัตถุ MatOfByte เป็นไบต์อาร์เรย์

แปลงไฟล์ MatOfByte วัตถุลงในอาร์เรย์ไบต์โดยใช้วิธีการ toArray().

byte[] byteArray = matOfByte.toArray();

ขั้นตอนที่ 3: การเตรียมวัตถุ InputStream

เตรียมวัตถุ InputStream โดยส่งอาร์เรย์ไบต์ที่สร้างขึ้นในขั้นตอนก่อนหน้าไปยังตัวสร้างของ ByteArrayInputStream ชั้นเรียน

//Preparing the InputStream object 
InputStream in = new ByteArrayInputStream(byteArray);

ขั้นตอนที่ 4: เตรียมวัตถุ InputStream

ส่งผ่านวัตถุ Input Stream ที่สร้างในขั้นตอนก่อนหน้าไปยังไฟล์ read() วิธีการของ ImageIOชั้นเรียน สิ่งนี้จะส่งคืนวัตถุ BufferedImage

//Preparing the BufferedImage 
BufferedImage bufImage = ImageIO.read(in);

การแสดงภาพโดยใช้ AWT / Swings

ในการแสดงภาพโดยใช้กรอบ AWT / Swings ก่อนอื่นให้อ่านภาพโดยใช้ imread() วิธีการและแปลงเป็นไฟล์ BufferedImage ทำตามขั้นตอนดังกล่าวข้างต้น

จากนั้นสร้างอินสแตนซ์ไฟล์ JFrame คลาสและเพิ่มอิมเมจบัฟเฟอร์ที่สร้างขึ้นใน ContentPane ของ JFrame ดังที่แสดงด้านล่าง -

//Instantiate JFrame 
JFrame frame = new JFrame();
 
//Set Content to the JFrame 
frame.getContentPane().add(new JLabel(new ImageIcon(bufImage))); 
frame.pack(); 
frame.setVisible(true);

Example

รหัสโปรแกรมต่อไปนี้แสดงให้เห็นว่าคุณทำได้อย่างไร read ภาพและ display ผ่านหน้าต่างสวิงโดยใช้ไลบรารี OpenCV

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.imgcodecs.Imgcodecs;

public class DisplayingImagesUsingSwings {
   public static void main(String args[]) throws Exception { 
      //Loading the OpenCV core library  
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME ); 
    
      //Reading the Image from the file and storing it in to a Matrix object 
      String file = "C:/EXAMPLES/OpenCV/sample.jpg"; 
      Mat image = Imgcodecs.imread(file); 
    
      //Encoding the image 
      MatOfByte matOfByte = new MatOfByte();       
      Imgcodecs.imencode(".jpg", image, matOfByte); 

      //Storing the encoded Mat in a byte array 
      byte[] byteArray = matOfByte.toArray(); 

      //Preparing the Buffered Image 
      InputStream in = new ByteArrayInputStream(byteArray); 
      BufferedImage bufImage = ImageIO.read(in); 

      //Instantiate JFrame 
      JFrame frame = new JFrame(); 

      //Set Content to the JFrame 
      frame.getContentPane().add(new JLabel(new ImageIcon(bufImage))); 
      frame.pack(); 
      frame.setVisible(true);
      
      System.out.println("Image Loaded");     
   } 
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Loaded

นอกจากนั้นคุณจะเห็นหน้าต่างที่แสดงภาพที่โหลดดังต่อไปนี้ -

การแสดงภาพโดยใช้ JavaFX

ในการแสดงภาพโดยใช้ JavaFX ก่อนอื่นให้อ่านภาพโดยใช้ไฟล์ imread() วิธีการและแปลงเป็นไฟล์ BufferedImage. จากนั้นแปลง BufferedImage เป็น WritableImage ดังที่แสดงด้านล่าง

WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

ผ่านสิ่งนี้ WritableImage คัดค้านตัวสร้างของ ImageView ชั้นเรียน

ImageView imageView = new ImageView(writableImage);

Example

รหัสโปรแกรมต่อไปนี้แสดงวิธีการ read ภาพและ display ผ่านหน้าต่าง JavaFX โดยใช้ไลบรารี OpenCV

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import javax.imageio.ImageIO;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.imgcodecs.Imgcodecs;

public class DisplayingImagesJavaFX extends Application {
   @Override 
   public void start(Stage stage) throws IOException {   
      WritableImage writableImage = loadImage(); 
  
      //Setting the image view 
      ImageView imageView = new ImageView(writableImage); 
        
      //Setting the position of the image 
      imageView.setX(50); 
      imageView.setY(25); 
        
      //setting the fit height and width of the image view 
      imageView.setFitHeight(400); 
      imageView.setFitWidth(500);
      
      //Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);
      
      //Creating a Group object  
      Group root = new Group(imageView);
      
      //Creating a scene object
      Scene scene = new Scene(root, 600, 400);
      
      //Setting title to the Stage 
      stage.setTitle("Loading an image");
      
      //Adding scene to the stage
      stage.setScene(scene);

      //Displaying the contents of the stage
      stage.show();
   } 
   public WritableImage loadImage() throws IOException {
      //Loading the OpenCV core library  
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
      
      //Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat image = Imgcodecs.imread(file);
      
      //Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", image, matOfByte);

      //Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();
      
      //Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray); 
      BufferedImage bufImage = ImageIO.read(in);

      System.out.println("Image Loaded");
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage; 
   }
   public static void main(String args[]) {
      launch(args); 
   } 
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Loaded

นอกจากนั้นคุณจะเห็นหน้าต่างที่แสดงภาพที่โหลดดังต่อไปนี้ -

OpenCV รองรับภาพประเภทต่างๆเช่นสีไบนารีโทนสีเทา ฯลฯ โดยใช้ไฟล์ imread() วิธีการและฟิลด์ที่กำหนดไว้ล่วงหน้าของ Imgcodecs ชั้นเรียนคุณสามารถอ่านรูปภาพที่กำหนดเป็นประเภทอื่นได้

พารามิเตอร์แฟล็กของ imread () method (IMREAD_XXX)

ในบทก่อนหน้านี้เราได้เห็นไวยากรณ์ของ imread() วิธีการของ Imgcodecsชั้นเรียน ยอมรับอาร์กิวเมนต์สตริงที่แสดงตำแหน่งของรูปภาพที่จะอ่าน

imread(filename)

imread() วิธีการมีไวยากรณ์อื่น

imread(filename, int flags)

ไวยากรณ์นี้ยอมรับสองพารามิเตอร์ -

  • filename - ยอมรับข้อโต้แย้ง (filename)ซึ่งเป็นตัวแปรประเภท String ที่แสดงเส้นทางของไฟล์ที่จะอ่าน

  • flags- ค่าจำนวนเต็มแทนค่าแฟล็กที่กำหนดไว้ล่วงหน้า สำหรับแต่ละค่าค่านี้จะอ่านรูปภาพที่กำหนดเป็นประเภทเฉพาะ (สีสเกลสีเทาเป็นต้น)

ต่อไปนี้เป็นตารางแสดงรายการฟิลด์ต่างๆที่มีให้ในไฟล์ Imgproc คลาสเป็นค่าสำหรับพารามิเตอร์นี้

ส. เลขที่ ฟิลด์และคำอธิบาย
1

IMREAD_COLOR

หากตั้งค่าสถานะเป็นค่านี้ภาพที่โหลดจะถูกแปลงเป็นภาพสี BGR 3 ช่อง (น้ำเงินเขียวแดง)

2

IMREAD_GRAYSCALE

หากตั้งค่าสถานะเป็นค่านี้ภาพที่โหลดจะถูกแปลงเป็นภาพสีเทาช่องเดียว

3

IMREAD_LOAD_GDAL

หากตั้งค่าสถานะเป็นค่านี้คุณสามารถโหลดภาพโดยใช้ไฟล์ gdal คนขับ.

4

IMREAD_ANYCOLOR

หากตั้งค่าสถานะเป็นค่านี้ภาพจะถูกอ่านในรูปแบบสีที่เป็นไปได้

5

IMREAD_REDUCED_COLOR_2

IMREAD_REDUCED_COLOR_4

IMREAD_REDUCED_COLOR_8

หากตั้งค่าสถานะเป็นค่านี้ภาพจะอ่านเป็น BGR สามช่องและขนาดของภาพจะลดลงเป็น½, ¼ thหรือ⅛ thของขนาดต้นฉบับของภาพตามช่องที่ใช้

6

IMREAD_REDUCED_GRAYSCALE_2

IMREAD_REDUCED_GRAYSCALE_4

IMREAD_REDUCED_GRAYSCALE_8

หากตั้งค่าสถานะเป็นค่านี้ภาพจะถูกอ่านเป็นภาพสีเทาช่องเดียวและขนาดของภาพจะลดลงเป็น½, ¼ thหรือ⅛ thของขนาดต้นฉบับของภาพตามช่องที่ใช้ .

7

IMREAD_UNCHANGED

หากตั้งค่าแฟล็กเป็นค่านี้รูปภาพที่โหลดจะถูกส่งกลับตามที่เป็นอยู่

โปรแกรมต่อไปนี้สาธิตวิธีการอ่านภาพสีเป็นโทนสีเทาและแสดงโดยใช้หน้าต่าง JavaFX ในที่นี้เราได้อ่านภาพโดยผ่านธงIMREAD_GRAYSCALE พร้อมกับ String ที่ถือเส้นทางของภาพสี

import java.awt.image.BufferedImage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

public class ReadingAsGrayscale extends Application {
   @Override
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);
      
      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);
      
      // Creating a Group object  
      Group root = new Group(imageView);
      
      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);
      
      // Setting title to the Stage
      stage.setTitle("Reading image as grayscale");
      
      // Adding scene to the stage
      stage.setScene(scene);
      
      // Displaying the contents of the stage
      stage.show();
   } 
   public WritableImage loadAndConvert() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the imagecodecs class
      Imgcodecs imageCodecs = new Imgcodecs();

      String input = "C:/EXAMPLES/OpenCV/sample.jpg";

      // Reading the image
      Mat src = imageCodecs.imread(input, Imgcodecs.IMREAD_GRAYSCALE);
       
      byte[] data1 = new byte[src.rows() * src.cols() * (int)(src.elemSize())];
      src.get(0, 0, data1);
      
      // Creating the buffered image
      BufferedImage bufImage = new BufferedImage(src.cols(),src.rows(), 
         BufferedImage.TYPE_BYTE_GRAY);
      
      // Setting the data elements to the image
      bufImage.getRaster().setDataElements(0, 0, src.cols(), src.rows(), data1);
              
      // Creating a WritableImage
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      System.out.println("Image Read");
      return writableImage;
   } 
   public static void main(String args[]) throws Exception { 
      launch(args); 
   } 
}

อินพุตรูปภาพ

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

ภาพที่ส่งออก

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้

โปรแกรมต่อไปนี้สาธิตวิธีการอ่านภาพสีเป็นภาพประเภท BGR และแสดงโดยใช้หน้าต่าง JavaFX ในที่นี้เราได้อ่านภาพโดยผ่านธงIMREAD_COLOR วิธีการ imread() พร้อมกับ String ที่ถือเส้นทางของภาพสี

import java.awt.image.BufferedImage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

public class ReadingAsColored extends Application {
   @Override 
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();
       
      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);
      
      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);
      
      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);
     
      // Setting title to the Stage
      stage.setTitle("Reading as colored image");

      // Adding scene to the stage
      stage.setScene(scene);
      
      // Displaying the contents of the stage
      stage.show();
   } 
   public WritableImage loadAndConvert() throws Exception {     
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
       
      String input = "C:/EXAMPLES/OpenCV/sample.jpg";
       
      Mat dst = new Mat();

      // Reading the image
      Mat src = Imgcodecs.imread(input, Imgcodecs.IMREAD_COLOR);

      byte[] data1 = new byte[src.rows() * src.cols() * (int)(src.elemSize())]; 
      src.get(0, 0, data1);
      
      // Creating the buffered image
      BufferedImage bufImage = new BufferedImage(src.cols(),src.rows(), 
         BufferedImage.TYPE_3BYTE_BGR);

      // Setting the data elements to the image 
      bufImage.getRaster().setDataElements(0, 0, src.cols(), src.rows(), data1);

      // Creating a WritableImage
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      System.out.println("Image read");
      return writableImage;
   } 
   public static void main(String args[]) throws Exception {
      launch(args);
   } 
}

อินพุตรูปภาพ

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

ภาพที่ส่งออก

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้

ในบทก่อนหน้านี้เราได้กล่าวถึงวิธีการอ่านภาพอินพุตเป็นประเภทต่างๆ (ไบนารีสีเทา BGR ฯลฯ ) ในบทนี้เราจะเรียนรู้วิธีการแปลงภาพประเภทหนึ่งเป็นอีกประเภทหนึ่ง

ชั้นเรียนชื่อ Imgproc ของแพ็คเกจ org.opencv.imgproc มีวิธีการแปลงภาพจากสีหนึ่งไปเป็นสีอื่น

การแปลงภาพสีเป็นโทนสีเทา

ชื่อเมธอด cvtColor()ใช้ในการแปลงภาพสีเป็นระดับสีเทา ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

cvtColor(Mat src, Mat dst, int code)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - เมทริกซ์แสดงแหล่งที่มา

  • dst - เมทริกซ์แสดงปลายทาง

  • code - รหัสจำนวนเต็มที่แสดงถึงประเภทของการแปลงเช่น RGB เป็น Grayscale

คุณสามารถแปลงภาพสีเป็นระดับสีเทาได้โดยการส่งรหัส Imgproc.COLOR_RGB2GRAY พร้อมกับเมทริกซ์ต้นทางและปลายทางเป็นพารามิเตอร์ของไฟล์ cvtColor() วิธี.

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการอ่านภาพสีเป็นภาพระดับสีเทาและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;
  
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;

import javafx.stage.Stage;

public class ColorToGrayscale extends Application {
   @Override
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();
       
      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Colored to grayscale image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   } 
   public WritableImage loadAndConvert() throws Exception {
      //Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      String input = "C:/EXAMPLES/OpenCV/sample.jpg";

      //Reading the image
      Mat src = Imgcodecs.imread(input);

      //Creating the empty destination matrix
      Mat dst = new Mat();

      //Converting the image to gray sacle and saving it in the dst matrix
      Imgproc.cvtColor(src, dst, Imgproc.COLOR_RGB2GRAY);
      
      //Extracting data from the transformed image (dst)
      byte[] data1 = new byte[dst.rows() * dst.cols() * (int)(dst.elemSize())];
      dst.get(0, 0, data1);

      //Creating Buffered image using the data
      BufferedImage bufImage = new BufferedImage(dst.cols(),dst.rows(), 
         BufferedImage.TYPE_BYTE_GRAY);

      //Setting the data elements to the image
      bufImage.getRaster().setDataElements(0, 0, dst.cols(), dst.rows(), data1);

      //Creating a WritableImage
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      System.out.println("Converted to Grayscale");
      return writableImage;
   }
   public static void main(String args[]) throws Exception {
      launch(args);
   }
}

อินพุตรูปภาพ

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

ภาพที่ส่งออก

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้

วิธีการที่เรียกว่า threshold()ใช้ในการแปลงภาพระดับสีเทาเป็นภาพไบนารี ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

threshold(Mat src, Mat dst, double thresh, double maxval, int type)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • mat - ก Mat วัตถุที่แสดงภาพอินพุต

  • dst - ก Mat วัตถุที่แสดงภาพที่ส่งออก

  • thresh - จำนวนเต็มแทนค่าขีด จำกัด

  • maxval - จำนวนเต็มแทนค่าสูงสุดที่จะใช้กับประเภทเกณฑ์ THRESH_BINARY_INV และ THRESH_BINARY_INV

  • type - รหัสจำนวนเต็มที่แสดงถึงประเภทของการแปลงเช่น RGB เป็น Grayscale

คุณสามารถแปลงภาพระดับสีเทาเป็นภาพไบนารีได้โดยส่งรหัส Imgproc.THRESH_BINARY พร้อมกับค่าไปยังพารามิเตอร์ที่เหลือ

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการอ่านภาพสีเป็นภาพไบนารีและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

public class ColorToBinary extends Application {
   @Override
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);
      
      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);
      
      // Setting title to the Stage
      stage.setTitle("Loading an image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage loadAndConvert() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the Imgcodecs class
      Imgcodecs imageCodecs = new Imgcodecs();
        
      // File input = new File("C:/EXAMPLES/OpenCV/sample.jpg");
      String input = "C:/EXAMPLES/OpenCV/sample.jpg";

      // Reading the image
      Mat src = imageCodecs.imread(input);

      // Creating the destination matrix
      Mat dst = new Mat();

      // Converting to binary image...
      Imgproc.threshold(src, dst, 200, 500, Imgproc.THRESH_BINARY);

      // Extracting data from the transformed image (dst)
      byte[] data1 = new byte[dst.rows() * dst.cols() * (int)(dst.elemSize())];
      dst.get(0, 0, data1);

      // Creating Buffered image using the data
      BufferedImage bufImage = new BufferedImage(dst.cols(),dst.rows(), 
         BufferedImage.TYPE_BYTE_GRAY);

      // Setting the data elements to the image
      bufImage.getRaster().setDataElements(0, 0, dst.cols(), dst.rows(), data1);

      // Creating a Writable image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      System.out.println("Converted to binary");
      return writableImage;
   }  
   public static void main(String args[]) throws Exception {
      launch(args);
   }
}

อินพุตรูปภาพ

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

ภาพที่ส่งออก

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้

คุณสามารถใช้วิธีการเดียวกับที่กล่าวถึงในบทก่อนหน้านี้เพื่อแปลงภาพระดับสีเทาเป็นภาพไบนารี เพียงแค่ส่งเส้นทางสำหรับภาพระดับสีเทาเป็นข้อมูลเข้าสู่โปรแกรมนี้

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการอ่านภาพสีเทาเป็นภาพไบนารีและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

public class GrayScaleToBinary extends Application {
   @Override
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();
       
      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);
      
      // Setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Grayscale to binary image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage loadAndConvert() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the imagecodecs class
      Imgcodecs imageCodecs = new Imgcodecs();

      String input = "E:/OpenCV/chap7/grayscale.jpg";

      // Reading the image
      Mat src = imageCodecs.imread(input);

      // Creating the destination matrix
      Mat dst = new Mat();

      // Converting to binary image...
      Imgproc.threshold(src, dst, 200, 500, Imgproc.THRESH_BINARY);

      // Extracting data from the transformed image (dst)
      byte[] data1 = new byte[dst.rows() * dst.cols() * (int)(dst.elemSize())];
      dst.get(0, 0, data1);

      // Creating Buffered image using the data
      BufferedImage bufImage = new BufferedImage(dst.cols(),dst.rows(), 
         BufferedImage.TYPE_BYTE_BINARY);

      // Setting the data elements to the image
      bufImage.getRaster().setDataElements(0, 0, dst.cols(), dst.rows(), data1);

      // Creating a Writable image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      System.out.println("Converted to binary");
      return writableImage;
   }
   public static void main(String args[]) throws Exception {
      launch(args);
   }
}

อินพุตรูปภาพ

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

ภาพที่ส่งออก

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้

คุณสามารถวาดรูปทรงต่างๆเช่น Circle, Rectangle, Line, Ellipse, Polylines, Convex, Polylines, Polylines บนภาพโดยใช้วิธีการตามลำดับของ org.opencv.imgproc แพ็คเกจ

คุณสามารถวาดวงกลมบนรูปภาพโดยใช้วิธี circle() ของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

circle(img, center, radius, color, thickness)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • mat - ก Mat วัตถุที่เป็นตัวแทนของภาพที่จะวาดวงกลม

  • point - ก Point วัตถุที่เป็นตัวแทนของศูนย์กลางของวงกลม

  • radius - ตัวแปรประเภท integer แทนรัศมีของวงกลม

  • scalar - ก Scalarวัตถุแทนสีของวงกลม (BGR)

  • thickness - อ integerแทนความหนาของวงกลม โดยค่าเริ่มต้นค่าของความหนาคือ 1

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการวาดวงกลมบนรูปภาพและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingCircle extends Application {
   Mat matrix = null;
   
   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingCircle obj = new DrawingCircle();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing Circle on the image");
      
      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }      
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      //Drawing a Circle Imgproc.circle ( matrix, //Matrix obj of the image new Point(230, 160), //Center of the circle 100, //Radius new Scalar(0, 0, 255), //Scalar object for color 10 //Thickness of the circle );
      
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);
      this.matrix = matrix;
      
      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

คุณสามารถวาดเส้นบนภาพโดยใช้วิธี line() ของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

line(img, pt1, pt2, color, thickness)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • mat - ก Mat วัตถุแทนภาพที่จะวาดเส้น

  • pt1 and pt2 - สอง Point วัตถุที่แสดงถึงจุดระหว่างที่จะลากเส้น

  • scalar - ก Scalarวัตถุแทนสีของวงกลม (BGR)

  • thickness- จำนวนเต็มแทนความหนาของเส้น โดยค่าเริ่มต้นค่าของความหนาคือ 1

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการลากเส้นบนรูปภาพและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingLine extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
   
      // Capturing the snapshot from the camera
      DrawingLine obj = new DrawingLine();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object  
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing a line on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      // Drawing a line Imgproc.line ( matrix, //Matrix obj of the image new Point(10, 200), //p1 new Point(300, 200), //p2 new Scalar(0, 0, 255), //Scalar object for color 5 //Thickness of the line );
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);

      this.matrix = matrix;

      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

คุณสามารถวาดรูปสี่เหลี่ยมผืนผ้าบนรูปภาพได้โดยใช้วิธี rectangle() ของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

rectangle(img, pt1, pt2, color, thickness)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • mat - ก Mat วัตถุแทนภาพที่จะวาดรูปสี่เหลี่ยม

  • pt1 and pt2 - สอง Point วัตถุที่แสดงจุดยอดของรูปสี่เหลี่ยมที่จะวาด

  • scalar - ก Scalarวัตถุแทนสีของสี่เหลี่ยมผืนผ้า (BGR)

  • thickness- จำนวนเต็มแทนความหนาของสี่เหลี่ยม โดยค่าเริ่มต้นค่าของความหนาคือ 1

ตัวอย่าง

ตัวอย่างต่อไปนี้สาธิตวิธีการวาดสี่เหลี่ยมผืนผ้าบนรูปภาพและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingRectangle extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingRectangle obj = new DrawingRectangle();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing Rectangle on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      // Drawing a Rectangle Imgproc.rectangle ( matrix, //Matrix obj of the image new Point(130, 50), //p1 new Point(300, 280), //p2 new Scalar(0, 0, 255), //Scalar object for color 5 //Thickness of the line );
      
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);

      this.matrix = matrix;

      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

คุณสามารถวาดวงรีบนรูปภาพโดยใช้วิธีการ rectangle() ของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

ellipse(img, box, color, thickness)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • mat - ก Mat วัตถุที่เป็นตัวแทนของภาพที่จะวาดสี่เหลี่ยมผืนผ้า

  • box - วัตถุ RotatedRect (วงรีถูกวาดไว้ในสี่เหลี่ยมผืนผ้านี้)

  • scalar - ก Scalarวัตถุแทนสีของสี่เหลี่ยมผืนผ้า (BGR)

  • thickness- จำนวนเต็มแทนความหนาของสี่เหลี่ยมผืนผ้า โดยค่าเริ่มต้นค่าของความหนาคือ 1

ตัวสร้างของ RotatedRect คลาสยอมรับอ็อบเจ็กต์ของคลาส Pointวัตถุของคลาส Size และตัวแปรประเภท double ดังที่แสดงด้านล่าง

RotatedRect(Point c, Size s, double a)

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการวาดวงรีบนรูปภาพและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.RotatedRect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingEllipse extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingEllipse obj = new DrawingEllipse();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing Ellipse on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      // Drawing an Ellipse Imgproc.ellipse ( matrix, //Matrix obj of the image new RotatedRect ( // RotatedRect(Point c, Size s, double a) new Point(200, 150), new Size(260, 180), 180 ), new Scalar(0, 0, 255), //Scalar object for color 10 //Thickness of the line );
      
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);

      this.matrix = matrix;
      
      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

คุณสามารถวาด Polylines บนภาพโดยใช้วิธี polylines() ของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

polylines(img, pts, isClosed, color, thickness)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • mat - ก Mat วัตถุที่เป็นตัวแทนของภาพที่จะวาด Polylines

  • pts - ก List วัตถุที่ถือวัตถุประเภท MatOfPoint.

  • isClosed - พารามิเตอร์ของประเภทบูลีนที่ระบุสภาพอากาศที่โพลีลีนถูกปิด

  • scalar - ก Scalarวัตถุแทนสีของ Polylines (BGR)

  • thickness- จำนวนเต็มแทนความหนาของโพลีลีน โดยค่าเริ่มต้นค่าของความหนาคือ 1

ตัวสร้างของ MatOfPoint คลาสยอมรับอ็อบเจ็กต์ของคลาส Point.

MatOfPoint(Point... a)

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการวาดโพลีไลน์บนรูปภาพและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingPolyLines extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingPolyLines obj = new DrawingPolyLines();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing Polylines on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }      
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      List<MatOfPoint> list = new ArrayList();
      list.add(
         new MatOfPoint (
            new Point(75, 100), new Point(350, 100),
            new Point(75, 150), new Point(350, 150),
            new Point(75, 200), new Point(350, 200),
            new Point(75, 250), new Point(350, 250)
         )
      );
      // Drawing polylines Imgproc.polylines ( matrix, // Matrix obj of the image list, // java.util.List<MatOfPoint> pts false, // isClosed new Scalar(0, 0, 255), // Scalar object for color 2 // Thickness of the line );
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);

      this.matrix = matrix;

      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

คุณสามารถวาดเส้นนูนบนภาพโดยใช้วิธี fillconvexPoly() ของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

fillConvexPoly(Mat img, MatOfPoint points, Scalar color)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • mat - ก Mat วัตถุที่เป็นตัวแทนของภาพที่จะวาด Polylines นูน

  • points - ก MatOfPoint วัตถุแทนจุดระหว่างที่จะวาดเส้นนูน

  • scalar - ก Scalarวัตถุแทนสีของ Polylines นูน (BGR)

ตัวสร้างของ MatOfPoint คลาสยอมรับอ็อบเจ็กต์ของคลาส Point.

MatOfPoint(Point... a)

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการวาดโพลีไลน์นูนบนรูปภาพและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class FillConvexPoly extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      FillConvexPoly obj = new FillConvexPoly();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      //Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing convex Polylines (fill) on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      MatOfPoint matOfPoint = new MatOfPoint (
         new Point(75, 100), new Point(350, 100),
         new Point(75, 150), new Point(350, 150),
         new Point(75, 200), new Point(350, 200),
         new Point(75, 250), new Point(350, 250)
      ); 
      // Drawing polylines Imgproc.fillConvexPoly ( matrix, // Matrix obj of the image matOfPoint, // java.util.List<MatOfPoint> pts new Scalar(0, 0, 255) // Scalar object for color );
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);
      this.matrix = matrix;
            
      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   } 
   public static void main(String args[]) {
      launch(args);
   }
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

คุณสามารถวาดเส้นลูกศรบนรูปภาพโดยใช้วิธีการ arrowedLine() ของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

arrowedLine(Mat img, Point pt1, Point pt2, Scalar color)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • mat - ก Mat วัตถุที่เป็นตัวแทนของภาพที่จะวาดเส้นลูกศร

  • pt1 and pt2 - สอง Point วัตถุที่แสดงถึงจุดระหว่างที่จะลากเส้นลูกศร

  • scalar - ก Scalarวัตถุแทนสีของเส้นลูกศร (BGR)

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการวาดเส้นลูกศรบนรูปภาพและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingArrowedLine extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingArrowedLine obj = new DrawingArrowedLine();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing a line on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/Aish.jpg";
      Mat matrix = Imgcodecs.imread(file);

      //Drawing a line Imgproc.arrowedLine( matrix, // Matrix obj of the image new Point(10, 200), // p1 new Point(590, 200), // p2 new Scalar(0, 100, 255) // Scalar object for color );

      // arrowedLine(Mat img, Point pt1, Point pt2, Scalar color)
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);
      this.matrix = matrix;

      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

คุณสามารถเพิ่มข้อความลงในรูปภาพโดยใช้วิธีการ arrowedLine() ของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

putText(img, text, org, fontFace, fontScale, Scalar color, int thickness)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • mat - ก Mat วัตถุที่แสดงภาพที่จะเพิ่มข้อความ

  • text - ก string ตัวแปรในการแสดงข้อความที่จะเพิ่ม

  • org - ก Point วัตถุแทนสตริงข้อความมุมล่างซ้ายในรูปภาพ

  • fontFace - ตัวแปรประเภทจำนวนเต็มแทนประเภทฟอนต์

  • fontScale - ตัวแปรประเภท double ที่แสดงถึงตัวคูณมาตราส่วนที่คูณด้วยขนาดฐานเฉพาะแบบอักษร

  • scalar - ก Scalarวัตถุแทนสีของข้อความที่จะเพิ่ม (BGR)

  • thickness - จำนวนเต็มแทนความหนาของเส้นโดยค่าเริ่มต้นค่าของความหนาคือ 1

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการเพิ่มข้อความลงในรูปภาพและแสดงโดยใช้หน้าต่าง JavaFX

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class AddingTextToImage extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      AddingTextToImage obj = new AddingTextToImage();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Adding text to an image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      // Adding Text Imgproc.putText ( matrix, // Matrix obj of the image "Ravivarma's Painting", // Text to be added new Point(10, 50), // point Core.FONT_HERSHEY_SIMPLEX , // front face 1, // front scale new Scalar(0, 0, 0), // Scalar object for color 4 // Thickness );
      
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);
      this.matrix = matrix;

      //Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

การเบลอ (การปรับให้เรียบ) คือการประมวลผลภาพที่ใช้กันทั่วไปเพื่อลดสัญญาณรบกวนของภาพ กระบวนการนี้จะลบเนื้อหาที่มีความถี่สูงเช่นขอบออกจากรูปภาพและทำให้มันราบรื่น

โดยทั่วไปการเบลอจะทำได้โดยการทำให้สับสน (แต่ละองค์ประกอบของภาพจะถูกเพิ่มไปยังเพื่อนบ้านในพื้นที่โดยให้น้ำหนักด้วยเคอร์เนล) ภาพผ่านเคอร์เนลตัวกรองความถี่ต่ำ

เบลอ (ค่าเฉลี่ย)

ในระหว่างการดำเนินการนี้ภาพจะได้รับการแก้ไขด้วยฟิลเตอร์กล่อง (ทำให้เป็นมาตรฐาน) ในกระบวนการนี้องค์ประกอบกลางของรูปภาพจะถูกแทนที่ด้วยค่าเฉลี่ยของพิกเซลทั้งหมดในพื้นที่เคอร์เนล

คุณสามารถดำเนินการนี้กับรูปภาพโดยใช้วิธีการ blur() ของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

blur(src, dst, ksize, anchor, borderType)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • ksize - ก Size วัตถุที่แสดงขนาดของเคอร์เนล

  • anchor - ตัวแปรประเภทจำนวนเต็มแทนจุดยึด

  • borderType - ตัวแปรประเภทจำนวนเต็มแทนชนิดของเส้นขอบที่จะใช้กับเอาต์พุต

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการหาค่าเฉลี่ย (เบลอ) บนรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class BlurTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating the Size and Point objects
      Size size = new Size(45, 45);
      Point point = new Point(20, 30);

      // Applying Blur effect on the Image
      Imgproc.blur(src, dst, size, point, Core.BORDER_DEFAULT);

      // blur(Mat src, Mat dst, Size ksize, Point anchor, int borderType)
      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap9/blur.jpg", dst);
      System.out.println("Image processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

ในการดำเนินการ Gaussian Blur ภาพจะถูกแปลงด้วยฟิลเตอร์ Gaussian แทนตัวกรองกล่อง ตัวกรอง Gaussian เป็นตัวกรองความถี่ต่ำที่ลบส่วนประกอบความถี่สูงจะลดลง

คุณสามารถดำเนินการนี้กับรูปภาพโดยใช้ไฟล์ Gaussianblur() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

GaussianBlur(src, dst, ksize, sigmaX)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • ksize - ก Size วัตถุที่แสดงขนาดของเคอร์เนล

  • sigmaX - ตัวแปรประเภท double ที่แสดงถึงค่าเบี่ยงเบนมาตรฐานของเคอร์เนล Gaussian ในทิศทาง X

ตัวอย่าง

โปรแกรมต่อไปนี้แสดงให้เห็นถึงวิธีดำเนินการเบลอแบบเกาส์เซียนบนรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class GaussianTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();
    
      // Applying GaussianBlur on the Image
      Imgproc.GaussianBlur(src, dst, new Size(45, 45), 0);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap9/Gaussian.jpg", dst);
      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

การดำเนินการเบลอค่ามัธยฐานคล้ายกับวิธีการหาค่าเฉลี่ยอื่น ๆ ที่นี่องค์ประกอบกลางของภาพจะถูกแทนที่ด้วยค่ามัธยฐานของพิกเซลทั้งหมดในพื้นที่เคอร์เนล การดำเนินการนี้ประมวลผลขอบในขณะที่ลบสัญญาณรบกวน

คุณสามารถดำเนินการนี้กับรูปภาพโดยใช้ไฟล์ medianBlur() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

medianBlur(src, dst, ksize)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • ksize - ก Size วัตถุที่แสดงขนาดของเคอร์เนล

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการเบลอค่ามัธยฐานบนรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class MedianBlurTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying MedianBlur on the Image
      Imgproc.medianBlur(src, dst, 15);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap9/median.jpg", dst);

      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

การกรองภาพช่วยให้คุณสามารถใช้เอฟเฟกต์ต่างๆกับภาพได้ ในบทนี้และอีกสามบทที่ตามมาเราจะพูดถึงการดำเนินการตัวกรองต่างๆเช่นตัวกรองทวิภาคีตัวกรองกล่องตัวกรองกล่อง SQR และตัวกรอง 2D

ตัวกรองทวิภาคี

การดำเนินการตัวกรองทวิภาคีใช้ภาพทวิภาคีกับตัวกรอง คุณสามารถดำเนินการนี้กับรูปภาพโดยใช้ไฟล์medianBlur() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

bilateralFilter(src, dst, d, sigmaColor, sigmaSpace, borderType)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • d - ตัวแปรประเภทจำนวนเต็มแทนเส้นผ่านศูนย์กลางของพิกเซลที่อยู่ใกล้เคียง

  • sigmaColor - ตัวแปรประเภทจำนวนเต็มแทนซิกม่าของฟิลเตอร์ในพื้นที่สี

  • sigmaSpace - ตัวแปรประเภทจำนวนเต็มแทนซิกม่าของฟิลเตอร์ในพื้นที่พิกัด

  • borderType - วัตถุจำนวนเต็มแทนชนิดของเส้นขอบที่ใช้

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการดำเนินการตัวกรองทวิภาคีบนรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class BilateralFilter {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap11/filter_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying Bilateral filter on the Image
      Imgproc.bilateralFilter(src, dst, 15, 80, 80, Core.BORDER_DEFAULT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap11/bilateralfilter.jpg", dst);

      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต filter_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

การทำงานของ Box Filter นั้นคล้ายกับการทำงานเบลอโดยเฉลี่ย ใช้ภาพทวิภาคีกับตัวกรอง ที่นี่คุณสามารถเลือกได้ว่าควรทำให้กล่องเป็นมาตรฐานหรือไม่

คุณสามารถดำเนินการนี้กับรูปภาพโดยใช้ไฟล์ boxFilter() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

boxFilter(src, dst, ddepth, ksize, anchor, normalize, borderType)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • ddepth - ตัวแปรประเภทจำนวนเต็มแทนความลึกของภาพที่ส่งออก

  • ksize - ก Size วัตถุที่แสดงขนาดของเคอร์เนลที่เบลอ

  • anchor - ตัวแปรประเภทจำนวนเต็มแทนจุดยึด

  • Normalize - ตัวแปรประเภทบูลีนที่ระบุสภาพอากาศที่เคอร์เนลควรทำให้เป็นมาตรฐาน

  • borderType - วัตถุจำนวนเต็มแทนชนิดของเส้นขอบที่ใช้

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการดำเนินการ Box Filter บนรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class BoxFilterTest {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file = "E:/OpenCV/chap11/filter_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating the objects for Size and Point
      Size size = new Size(45, 45);
      Point point = Point(-1, -1);

      // Applying Box Filter effect on the Image
      Imgproc.boxFilter(src, dst, 50, size, point, true, Core.BORDER_DEFAULT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap11/boxfilterjpg", dst);

      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต filter_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

คุณสามารถดำเนินการตัวกรอง SQRBox บนรูปภาพโดยใช้ไฟล์ boxFilter() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

sqrBoxFilter(src, dst, ddepth, ksize)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • ddepth - ตัวแปรประเภทจำนวนเต็มแทนความลึกของภาพที่ส่งออก

  • ksize - ก Size วัตถุที่แสดงขนาดของเคอร์เนลที่เบลอ

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการกรอง Sqrbox บนรูปภาพที่กำหนด

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class SqrBoxFilterTest {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap11/filter_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying Box Filter effect on the Image
      Imgproc.sqrBoxFilter(src, dst, -1, new Size(1, 1));
     
      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap11/sqrboxfilter.jpg", dst);

      System.out.println("Image Processed");
   } 
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต filter_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

การดำเนินการ Filter2D แปลงรูปภาพด้วยเคอร์เนล คุณสามารถดำเนินการนี้กับรูปภาพโดยใช้ไฟล์Filter2D() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

filter2D(src, dst, ddepth, kernel)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • ddepth - ตัวแปรประเภทจำนวนเต็มแทนความลึกของภาพที่ส่งออก

  • kernel - ก Mat วัตถุที่แสดงถึงเคอร์เนล Convolution

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการ Filter2D บนรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class Filter2D {
   public static void main( String[] args ) {
      //Loading the OpenCV core library  
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      //Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap11/filter_input.jpg";
      Mat src = Imgcodecs.imread(file);

      //Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating kernel matrix
      Mat kernel = Mat.ones(2,2, CvType.CV_32F);
      
      for(int i = 0; i<kernel.rows(); i++) {
         for(int j = 0; j<kernel.cols(); j++) {
            double[] m = kernel.get(i, j);

            for(int k = 1; k<m.length; k++) {
               m[k] = m[k]/(2 * 2);
            }
            kernel.put(i,j, m);
         }
      }
      Imgproc.filter2D(src, dst, -1, kernel);
      Imgcodecs.imwrite("E:/OpenCV/chap11/filter2d.jpg", dst);
      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต filter_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

การกร่อนและการขยายตัวเป็นสองประเภทของการดำเนินการทางสัณฐานวิทยา ตามความหมายของชื่อการดำเนินการทางสัณฐานวิทยาคือชุดของการดำเนินการที่ประมวลผลภาพตามรูปร่าง

จากภาพอินพุตที่กำหนด "องค์ประกอบโครงสร้าง" ได้รับการพัฒนา ซึ่งอาจทำได้ในสองขั้นตอน สิ่งเหล่านี้มีจุดมุ่งหมายเพื่อลบจุดรบกวนและจัดการกับความไม่สมบูรณ์เพื่อให้ภาพมีความชัดเจน

การขยายตัว

ขั้นตอนนี้เป็นไปตามการแปลงด้วยเคอร์เนลที่มีรูปร่างเฉพาะเช่นสี่เหลี่ยมจัตุรัสหรือวงกลม เคอร์เนลนี้มีจุดยึดซึ่งแสดงถึงจุดศูนย์กลาง

เคอร์เนลนี้ซ้อนทับกับรูปภาพเพื่อคำนวณค่าพิกเซลสูงสุด หลังจากคำนวณภาพจะถูกแทนที่ด้วยจุดยึดที่กึ่งกลาง ด้วยขั้นตอนนี้พื้นที่ของบริเวณที่สว่างจะมีขนาดใหญ่ขึ้นและด้วยเหตุนี้ขนาดภาพจึงเพิ่มขึ้น

ตัวอย่างเช่นขนาดของวัตถุในที่ร่มสีขาวหรือที่สว่างจะเพิ่มขึ้นในขณะที่ขนาดของวัตถุในที่ร่มสีดำหรือในที่มืดจะลดลง

คุณสามารถทำการขยายภาพโดยใช้ไฟล์ dilate() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

dilate(src, dst, kernel)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • kernel - ก Mat วัตถุแทนเคอร์เนล

ตัวอย่าง

คุณสามารถเตรียมเคอร์เนลเมทริกซ์โดยใช้ getStructuringElement()วิธี. วิธีนี้ยอมรับจำนวนเต็มที่แสดงถึงmorph_rect ประเภทและวัตถุประเภท Size.

Imgproc.getStructuringElement(int shape, Size ksize);

โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการขยายภาพที่กำหนด

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DilateTest {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Preparing the kernel matrix object 
      Mat kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, 
         new  Size((2*2) + 1, (2*2)+1));

      // Applying dilate on the Image
      Imgproc.dilate(src, dst, kernel);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap10/Dilation.jpg", dst);

      System.out.println("Image Processed");
   } 
}

อินพุต

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

การกัดเซาะเป็นกระบวนการที่คล้ายคลึงกับการขยายตัว แต่ค่าพิกเซลที่คำนวณที่นี่เป็นค่าต่ำสุดแทนที่จะเป็นค่าสูงสุดในการขยาย รูปภาพจะถูกแทนที่ภายใต้จุดยึดด้วยค่าพิกเซลขั้นต่ำนั้น

ด้วยขั้นตอนนี้พื้นที่ของบริเวณที่มืดจะมีขนาดเพิ่มขึ้นและพื้นที่สว่างจะลดลง ตัวอย่างเช่นขนาดของวัตถุในที่มืดหรือในที่ร่มสีดำจะเพิ่มขึ้นในขณะที่วัตถุจะลดลงในที่ร่มสีขาวหรือที่สว่าง

ตัวอย่าง

คุณสามารถดำเนินการนี้กับรูปภาพโดยใช้ไฟล์ erode() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

erode(src, dst, kernel)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • kernel - ก Mat วัตถุแทนเคอร์เนล

คุณสามารถเตรียมเคอร์เนลเมทริกซ์โดยใช้ getStructuringElement()วิธี. วิธีนี้ยอมรับจำนวนเต็มที่แสดงถึงmorph_rect ประเภทและวัตถุประเภท Size.

Imgproc.getStructuringElement(int shape, Size ksize);

โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการกัดเซาะบนภาพที่กำหนด

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class ErodeTest {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Preparing the kernel matrix object
      Mat kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, 
         new  Size((2*2) + 1, (2*2)+1));

      // Applying erode on the Image
      Imgproc.erode(src, dst, kernel);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap10/Erosion.jpg", dst);

      System.out.println("Image processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต sample.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Loaded

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

ในบทก่อนหน้านี้เราได้กล่าวถึงกระบวนการของ erosion และ dilation. นอกจากสองสิ่งนี้แล้ว OpenCV ยังมีการเปลี่ยนแปลงทางสัณฐานวิทยามากขึ้น morphologyEx() ของวิธีการของคลาส Imgproc ใช้เพื่อดำเนินการเหล่านี้กับรูปภาพที่กำหนด

ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

morphologyEx(src, dst, op, kernel)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

  • dst - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

  • op - จำนวนเต็มแสดงประเภทของการดำเนินการทางสัณฐานวิทยา

  • kernel - เมทริกซ์เคอร์เนล

ตัวอย่าง

โปรแกรมต่อไปนี้แสดงให้เห็นถึงวิธีการใช้การดำเนินการทางสัณฐานวิทยา "top-hat" บนรูปภาพโดยใช้ไลบรารี OpenCV

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class MorphologyExTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap12/morph_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating kernel matrix
      Mat kernel = Mat.ones(5,5, CvType.CV_32F);

      // Applying Blur effect on the Image 
      Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap12/morph_tophat.jpg", dst);

      System.out.println("Image Processed");
   } 
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต morph_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

การดำเนินงานเพิ่มเติม

นอกเหนือจากการดำเนินการทางสัณฐานวิทยา TOPHATแสดงให้เห็นในก่อนหน้านี้ exampleOpenCV ให้บริการลักษณะทางสัณฐานวิทยาประเภทอื่น ๆ ประเภททั้งหมดเหล่านี้แสดงโดยฟิลด์คงที่ที่กำหนดไว้ล่วงหน้า (ค่าคงที่) ของImgproc ชั้นเรียน

คุณสามารถเลือกประเภทของสัณฐานวิทยาที่คุณต้องการได้โดยส่งค่าที่กำหนดไว้ล่วงหน้าตามลำดับไปยังพารามิเตอร์ op ของ morphologyEx() วิธี.

// Applying Blur effect on the Image
Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel);

ต่อไปนี้เป็นค่าที่แสดงถึงประเภทของการดำเนินการทางสัณฐานวิทยาและผลลัพธ์ตามลำดับ

การทำงานและคำอธิบาย เอาต์พุต
MORPH_BLACKHAT
MORPH_CLOSE
MORPH_CROSS
MORPH_DILATE
MORPH_ELLIPSE
MORPH_ERODE
MORPH_GRADIENT
MORPH_OPEN
MORPH_RECT
MORPH_TOPHAT

พีระมิดเป็นการดำเนินการกับรูปภาพที่

  • ภาพอินพุตจะถูกปรับให้เรียบในขั้นต้นโดยใช้ฟิลเตอร์ปรับความเรียบโดยเฉพาะ (เช่น Gaussian, Laplacian) จากนั้นภาพที่ปรับให้เรียบจะถูกสุ่มตัวอย่าง

  • กระบวนการนี้ซ้ำหลายครั้ง

ในระหว่างการทำงานของพีระมิดความเรียบของภาพจะเพิ่มขึ้นและความละเอียด (ขนาด) จะลดลง

พีระมิดขึ้น

ใน Pyramid Up ภาพจะถูกสุ่มตัวอย่างในขั้นต้นแล้วเบลอ คุณสามารถดำเนินการ Pyramid Up บนรูปภาพโดยใช้ไฟล์pyrUP() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

pyrUp(src, dst, dstsize, borderType)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

  • mat - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

  • size - วัตถุของคลาส Size แทนขนาดที่จะเพิ่มหรือลดภาพ

  • borderType - ตัวแปรประเภทจำนวนเต็มแทนประเภทของเส้นขอบที่จะใช้

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการ Pyramid Up บนรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class PyramidUp {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap13/pyramid_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying pyrUp on the Image
      Imgproc.pyrUp(src, dst, new Size(src.cols()*2,  src.rows()*2), Core.BORDER_DEFAULT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap13/pyrUp_output.jpg", dst);

      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต pyramid_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

พีระมิดลง

ใน Pyramid Down ภาพจะเบลอในขั้นต้นจากนั้นจึงสุ่มตัวอย่างลง คุณสามารถดำเนินการ Pyramid Down บนรูปภาพโดยใช้ไฟล์pyrDown() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

pyrDown(src, dst, dstsize, borderType)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

  • mat - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

  • size - วัตถุของคลาส Size แทนขนาดที่จะเพิ่มหรือลดภาพ

  • borderType - ตัวแปรประเภทจำนวนเต็มแทนประเภทของเส้นขอบที่จะใช้

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการดำเนินการ Pyramid Down บนรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class PyramidDown {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap13/pyramid_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying pyrDown on the Image
      Imgproc.pyrDown(src, dst, new Size(src.cols()/2,  src.rows()/2),
         Core.BORDER_DEFAULT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap13/pyrDown_output.jpg", dst);

      System.out.println("Image Processed");
   } 
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต pyramid_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

หมายถึงการกรองกะ

ในการดำเนินการหมายถึงการขยับพีระมิดขั้นตอนเริ่มต้นของการแบ่งส่วนการกะค่าเฉลี่ยของรูปภาพจะดำเนินการ

คุณสามารถดำเนินการกรองค่าเฉลี่ยกะพีระมิดบนรูปภาพโดยใช้ไฟล์ pyrDown() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

pyrMeanShiftFiltering(src, dst, sp, sr)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

  • mat - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

  • sp - ตัวแปรประเภท double ที่แสดงถึงรัศมีของหน้าต่างเชิงพื้นที่

  • sr - ตัวแปรประเภท double แสดงรัศมีหน้าต่างสี

ตัวอย่าง

โปรแกรมต่อไปนี้แสดงให้เห็นถึงวิธีการดำเนินการ Mean Shift Filtering บนรูปภาพที่กำหนด

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class PyramidMeanShift {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap13/pyramid_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying meanShifting on the Image
      Imgproc.pyrMeanShiftFiltering(src, dst, 200, 300);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap13/meanShift_output.jpg", dst);
      
      System.out.println("Image Processed");
   } 
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต pyramid_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

Thresholding เป็นวิธีการแบ่งส่วนภาพโดยทั่วไปจะใช้เพื่อสร้างภาพไบนารี Thresholding แบ่งออกเป็น 2 ประเภท ได้แก่ Thresholding และ Adaptive Thresholding

เกณฑ์ง่าย ๆ

ในการดำเนินการขีด จำกัด อย่างง่ายพิกเซลที่มีค่ามากกว่าค่าขีด จำกัด ที่ระบุจะถูกกำหนดด้วยค่ามาตรฐาน

คุณสามารถดำเนินการขีด จำกัด อย่างง่ายบนรูปภาพโดยใช้วิธีการ threshold() ของ Imgproc classต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

threshold(src, dst, thresh, maxval, type)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

  • dst - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

  • thresh - ตัวแปรประเภทคู่ที่แสดงถึงค่าขีด จำกัด

  • maxval - ตัวแปรประเภทคู่ที่แสดงถึงค่าที่จะกำหนดหากค่าพิกเซลมากกว่าค่าเกณฑ์

  • type - ตัวแปรประเภทจำนวนเต็มแทนประเภทของขีด จำกัด ที่จะใช้

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการขีด จำกัด อย่างง่ายบนรูปภาพใน OpenCV

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class Thresh {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap14/thresh_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();
      Imgproc.threshold(src, dst, 50, 255, Imgproc.THRESH_BINARY);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap14/thresh_trunc.jpg", dst);

      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต thresh_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

เกณฑ์ง่ายๆประเภทอื่น ๆ

นอกเหนือไปจาก THRESH_BINARYการดำเนินการที่แสดงในตัวอย่างก่อนหน้านี้ OpenCV รองรับการดำเนินการตามเกณฑ์ประเภทอื่น ๆ ประเภททั้งหมดเหล่านี้แสดงโดยฟิลด์คงที่ที่กำหนดไว้ล่วงหน้า (ค่าคงที่) ของImgproc ชั้นเรียน

คุณสามารถเลือกประเภทของการดำเนินการขีด จำกัด ที่คุณต้องการได้โดยส่งค่าที่กำหนดไว้ล่วงหน้าตามลำดับไปยังพารามิเตอร์ที่ชื่อ type ของ threshold() วิธี.

Imgproc.threshold(src, dst, 50, 255, Imgproc.THRESH_BINARY);

ต่อไปนี้เป็นค่าที่แสดงถึงประเภทต่างๆของการดำเนินการขีด จำกัด และผลลัพธ์ตามลำดับ

การทำงานและคำอธิบาย เอาต์พุต
THRESH_BINARY
THRESH_BINARY_INV
THRESH_TRUNC
THRESH_TOZERO
THRESH_TOZERO_INV

ใน simple thresholdingค่าขีด จำกัด เป็นค่าส่วนกลางกล่าวคือพิกเซลทั้งหมดในภาพจะเท่ากัน Adaptive thresholding เป็นวิธีการที่คำนวณค่าขีด จำกัด สำหรับพื้นที่ขนาดเล็กดังนั้นจึงมีค่าขีด จำกัด ที่แตกต่างกันสำหรับภูมิภาคต่างๆ

ใน OpenCV คุณสามารถดำเนินการ Adaptive threshold บนรูปภาพโดยใช้วิธีการ adaptiveThreshold() ของ Imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

adaptiveThreshold(src, dst, maxValue, adaptiveMethod, thresholdType, blockSize, C)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

  • dst - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

  • maxValue - ตัวแปรประเภทคู่ที่แสดงถึงค่าที่จะกำหนดหากค่าพิกเซลมากกว่าค่าเกณฑ์

  • adaptiveMethod- ตัวแปรของจำนวนเต็มประเภทที่แสดงถึงวิธีการปรับเปลี่ยนที่จะใช้ ค่านี้จะเป็นสองค่าต่อไปนี้

    • ADAPTIVE_THRESH_MEAN_C - ค่า threshold คือค่าเฉลี่ยของพื้นที่ใกล้เคียง

    • ADAPTIVE_THRESH_GAUSSIAN_C - ค่าขีด จำกัด คือผลรวมถ่วงน้ำหนักของค่าย่านใกล้เคียงโดยที่น้ำหนักเป็นหน้าต่างแบบเสียน

  • thresholdType - ตัวแปรประเภทจำนวนเต็มแทนประเภทของขีด จำกัด ที่จะใช้

  • blockSize - ตัวแปรประเภทจำนวนเต็มแสดงขนาดของพิกเซลพื้นที่ที่ใช้ในการคำนวณค่าขีด จำกัด

  • C - ตัวแปรประเภทคู่แทนค่าคงที่ที่ใช้ในทั้งสองวิธี (ลบออกจากค่าเฉลี่ยหรือค่าเฉลี่ยถ่วงน้ำหนัก)

  • ตัวอย่าง

    โปรแกรมต่อไปนี้แสดงให้เห็นถึงวิธีดำเนินการ Adaptive threshold บนอิมเมจใน OpenCV ที่นี่เรากำลังเลือกเกณฑ์การปรับตัวของประเภทbinary และ ADAPTIVE_THRESH_MEAN_C สำหรับวิธีเกณฑ์

    import org.opencv.core.Core;
    import org.opencv.core.Mat;
    import org.opencv.imgcodecs.Imgcodecs;
    import org.opencv.imgproc.Imgproc;
    
    public class AdaptiveThresh {
       public static void main(String args[]) throws Exception {
          // Loading the OpenCV core library
          System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
    
          // Reading the Image from the file and storing it in to a Matrix object
          String file ="E:/OpenCV/chap14/thresh_input.jpg";
          
          // Reading the image
          Mat src = Imgcodecs.imread(file,0);
    
          // Creating an empty matrix to store the result
          Mat dst = new Mat();
    
          Imgproc.adaptiveThreshold(src, dst, 125, Imgproc.ADAPTIVE_THRESH_MEAN_C,
             Imgproc.THRESH_BINARY, 11, 12);
    
          // Writing the image
          Imgcodecs.imwrite("E:/OpenCV/chap14/Adaptivemean_thresh_binary.jpg", dst);
    
          System.out.println("Image Processed");
       } 
    }

    สมมติว่าต่อไปนี้เป็นภาพอินพุต thresh_input.jpg ระบุไว้ในโปรแกรมข้างต้น

    เอาต์พุต

    ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

    Image Processed

    หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

    เกณฑ์การปรับตัวประเภทอื่น ๆ

    นอกเหนือไปจาก ADAPTIVE_THRESH_MEAN_C เป็นวิธีการปรับตัวและ THRESH_BINARY เป็นประเภทเกณฑ์ตามที่แสดงในตัวอย่างก่อนหน้านี้เราสามารถเลือกชุดค่าผสมทั้งสองนี้ได้มากขึ้น

    Imgproc.adaptiveThreshold(src, dst, 125, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 11, 12);

    ต่อไปนี้เป็นค่าที่แสดงถึงชุดค่าต่างๆสำหรับพารามิเตอร์ adaptiveMethod และ thresholdType และผลลัพธ์ตามลำดับ

    adaptiveMethod / thresholdType ADAPTIVE_THRESH_MEAN_C ADAPTIVE_THRESH_GAUSSIAN_C:
    THRESH_BINARY
    THRESH_BINARY_INV

    บทนี้จะสอนให้คุณรู้ว่าคางคกมีขอบภาพอย่างไร

    copyMakeBorder () วิธีการ

    คุณสามารถเพิ่มเส้นขอบต่างๆให้กับรูปภาพโดยใช้วิธีนี้ copyMakeBorder() ของคลาสชื่อ Core ซึ่งเป็นของแพ็กเกจ org.opencv.core. ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

    copyMakeBorder(src, dst, top, bottom, left, right, borderType)

    วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

    • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

    • dst - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

    • top - ตัวแปรของจำนวนเต็มประเภทจำนวนเต็มแทนความยาวของเส้นขอบที่ด้านบนของรูปภาพ

    • bottom - ตัวแปรของจำนวนเต็มประเภทจำนวนเต็มแทนความยาวของเส้นขอบที่ด้านล่างของรูปภาพ

    • left - ตัวแปรของจำนวนเต็มประเภทจำนวนเต็มแทนความยาวของเส้นขอบทางด้านซ้ายของรูปภาพ

    • right - ตัวแปรของจำนวนเต็มชนิดจำนวนเต็มแทนความยาวของเส้นขอบทางด้านขวาของรูปภาพ

    • borderType - ตัวแปรชนิดจำนวนเต็มแทนชนิดของเส้นขอบที่จะใช้

    ตัวอย่าง

    โปรแกรมต่อไปนี้เป็นตัวอย่างการสาธิตวิธีการเพิ่มเส้นขอบให้กับภาพที่กำหนด

    import org.opencv.core.Core;
    import org.opencv.core.Mat;
    import org.opencv.imgcodecs.Imgcodecs;
    
    public class AddingBorder {
       public static void main( String[] args ) {
          // Loading the OpenCV core library
          System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         
          // Reading the Image from the file and storing it in to a Matrix object
          String file ="E:/OpenCV/chap15/input.jpg";
          Mat src = Imgcodecs.imread(file);
    
          // Creating an empty matrix to store the result
          Mat dst = new Mat();
       
          Core.copyMakeBorder(src, dst, 20, 20, 20, 20, Core.BORDER_CONSTANT);
          Imgcodecs.imwrite("E:/OpenCV/chap15/border_constant.jpg", dst);
    
          System.out.println("Image Processed");
       }
    }

    สมมติว่าต่อไปนี้เป็นภาพอินพุต thresh_input.jpg ระบุไว้ในโปรแกรมข้างต้น

    เอาต์พุต

    ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

    Image Processed

    หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

    พรมแดนประเภทอื่น ๆ

    นอกจากประเภทเส้นขอบแล้ว BORDER_CONSTANTแสดงให้เห็นในตัวอย่างก่อนหน้า OpenCV ให้บริการพรมแดนประเภทอื่น ๆ ประเภททั้งหมดนี้แสดงโดยฟิลด์คงที่ที่กำหนดไว้ล่วงหน้า (ค่าคงที่) ของคลาส Core

    คุณสามารถเลือกประเภทของการดำเนินการขีด จำกัด ที่คุณต้องการได้โดยส่งค่าที่กำหนดไว้ล่วงหน้าตามลำดับไปยังพารามิเตอร์ที่ชื่อ borderType ของ copyMakeBorder() วิธี.

    Core.copyMakeBorder(src, dst, 20, 20, 20, 20, Core.BORDER_CONSTANT);

    ต่อไปนี้เป็นค่าที่แสดงถึงการดำเนินการเกี่ยวกับพรมแดนประเภทต่างๆและผลลัพธ์ที่เกี่ยวข้อง

    การทำงานและคำอธิบาย เอาต์พุต
    BORDER_CONSTANT
    BORDER_ISOLATED
    BORDER_DEFAULT
    BORDER_REFLECT
    BORDER_REFLECT_101
    BORDER_REFLECT101
    BORDER_REPLICATE
    BORDER_WRAP

    ใช้ sobel operationคุณสามารถตรวจจับขอบของภาพได้ทั้งในแนวนอนและแนวตั้ง คุณสามารถใช้การดำเนินการ sobel กับภาพโดยใช้วิธีการsobel(). ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

    Sobel(src, dst, ddepth, dx, dy)

    วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

    • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

    • dst - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

    • ddepth - ตัวแปรจำนวนเต็มแสดงความลึกของภาพ (-1)

    • dx- ตัวแปรจำนวนเต็มแทนอนุพันธ์ x (0 หรือ 1)

    • dy- ตัวแปรจำนวนเต็มแทนอนุพันธ์ y (0 หรือ 1)

    ตัวอย่าง

    โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการ Sobel บนรูปภาพที่กำหนด

    import org.opencv.core.Core;
    import org.opencv.core.Mat;
    
    import org.opencv.imgcodecs.Imgcodecs;
    import org.opencv.imgproc.Imgproc;
    
    public class SobelTest {
       public static void main(String args[]) {
          // Loading the OpenCV core library
          System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    
          // Reading the Image from the file and storing it in to a Matrix object
          String file ="E:/OpenCV/chap16/sobel_input.jpg";
          Mat src = Imgcodecs.imread(file);
    
          // Creating an empty matrix to store the result
          Mat dst = new Mat();
    
          // Applying sobel on the Image
          Imgproc.Sobel(src, dst, -1, 1, 1);
    
          // Writing the image
          Imgcodecs.imwrite("E:/OpenCV/chap16/sobel_output.jpg", dst);
    
          System.out.println("Image processed");
       }
    }

    สมมติว่าต่อไปนี้เป็นภาพอินพุต sobel_input.jpg ระบุไว้ในโปรแกรมข้างต้น

    เอาต์พุต

    ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

    Image Processed

    หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

    sobel ตัวแปร

    ในการส่งผ่านค่าต่าง ๆ ไปยังพารามิเตอร์สุดท้าย (dx และ dy) (ระหว่าง 0 และ 1) คุณจะได้ผลลัพธ์ที่แตกต่างกัน -

    // Applying sobel on the Image
    Imgproc.Sobel(src, dst, -1, 1, 1);

    ตารางต่อไปนี้แสดงค่าต่างๆสำหรับตัวแปร dx และ dy ของวิธีการ Sobel() และผลลัพธ์ตามลำดับ

    X- อนุพันธ์ Y- อนุพันธ์ เอาต์พุต
    0 1
    1 0
    1 1

    Scharr ยังใช้เพื่อตรวจจับอนุพันธ์อันดับสองของภาพในแนวนอนและแนวตั้ง คุณสามารถดำเนินการ scharr กับรูปภาพโดยใช้วิธีการscharr(). ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

    Scharr(src, dst, ddepth, dx, dy)

    วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

    • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

    • dst - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

    • ddepth - ตัวแปรจำนวนเต็มแสดงความลึกของภาพ (-1)

    • dx- ตัวแปรจำนวนเต็มแทนอนุพันธ์ x (0 หรือ 1)

    • dy- ตัวแปรจำนวนเต็มแทนอนุพันธ์ y (0 หรือ 1)

    ตัวอย่าง

    โปรแกรมต่อไปนี้สาธิตวิธีใช้ scharr กับภาพที่กำหนด

    import org.opencv.core.Core;
    import org.opencv.core.Mat;
    
    import org.opencv.imgcodecs.Imgcodecs;
    import org.opencv.imgproc.Imgproc;
    
    public class ScharrTest {
    
       public static void main( String[] args ) {
    
          // Loading the OpenCV core library
          System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
    
          // Reading the Image from the file and storing it in to a Matrix object
          String file ="E:/OpenCV/chap16/sobel_input.jpg";
          Mat src = Imgcodecs.imread(file);
    
          // Creating an empty matrix to store the result
          Mat dst = new Mat();
    
          // Applying Box Filter effect on the Image
          Imgproc.Scharr(src, dst, Imgproc.CV_SCHARR, 0, 1);
    
          // Writing the image
          Imgcodecs.imwrite("E:/OpenCV/chap16/scharr_output.jpg", dst);
    
          System.out.println("Image processed");
       }
    }

    สมมติว่าต่อไปนี้เป็นภาพอินพุต scharr_input.jpg ระบุไว้ในโปรแกรมข้างต้น

    เอาต์พุต

    ในการดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้ -

    Image Processed

    หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

    อนุพันธ์ scharr เพิ่มเติม

    ในการส่งผ่านค่าที่แตกต่างกันไปยังพารามิเตอร์สุดท้าย (dx และ dy) (ระหว่าง 0 และ 1) คุณจะได้ผลลัพธ์ที่แตกต่างกัน -

    // Applying scharr on the Image
    Imgproc.Scharr(src, dst, -1, 1, 1);

    ต่อไปนี้เป็นตารางแสดงรายการค่าต่างๆสำหรับตัวแปร dx และ dy ของวิธีการ scharr() และผลลัพธ์ตามลำดับ

    X- อนุพันธ์ Y- อนุพันธ์ เอาต์พุต
    0 1
    1 0

    Laplacian Operator ยังเป็นตัวดำเนินการอนุพันธ์ที่ใช้ในการหาขอบในภาพ เป็นมาสก์อนุพันธ์อันดับสอง ในหน้ากากนี้เรามีการจำแนกประเภทเพิ่มเติมอีกสองประเภทหนึ่งคือตัวดำเนินการ Laplacian เชิงบวกและอีกประเภทหนึ่งคือตัวดำเนินการ Laplacian เชิงลบ

    ซึ่งแตกต่างจากตัวดำเนินการอื่น ๆ Laplacian ไม่ได้ใช้ขอบในทิศทางใดทิศทางหนึ่ง แต่จะใช้ขอบในการจำแนกประเภทต่อไปนี้

    • ขอบขาเข้า
    • ขอบด้านนอก

    คุณสามารถดำเนินการ Laplacian Transform การทำงานกับภาพโดยใช้ไฟล์ Laplacian() วิธีการของ imgproc คลาสต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

    Laplacian(src, dst, ddepth)

    วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

    • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

    • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

    • ddepth - ตัวแปรประเภทจำนวนเต็มแสดงความลึกของภาพปลายทาง

    ตัวอย่าง

    โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการแปลง Laplace บนรูปภาพที่กำหนด

    import org.opencv.core.Core;
    import org.opencv.core.Mat;
    import org.opencv.imgcodecs.Imgcodecs;
    import org.opencv.imgproc.Imgproc;
    
    public class LaplacianTest {
       public static void main(String args[]) {
          // Loading the OpenCV core library
          System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    
          //Reading the Image from the file and storing it in to a Matrix object
          String file ="E:/OpenCV/chap18/laplacian_input.jpg";
          Mat src = Imgcodecs.imread(file);
    
          // Creating an empty matrix to store the result
          Mat dst = new Mat();
    
          // Applying GaussianBlur on the Image
          Imgproc.Laplacian(src, dst, 10);
    
          // Writing the image
          Imgcodecs.imwrite("E:/OpenCV/chap18/laplacian.jpg", dst);
    
          System.out.println("Image Processed");
       }
    }

    สมมติว่าต่อไปนี้เป็นภาพอินพุต laplacian_input.jpg ระบุไว้ในโปรแกรมข้างต้น

    เอาต์พุต

    ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

    Image Processed

    หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

    distance transformโดยทั่วไปแล้วตัวดำเนินการจะใช้ภาพไบนารีเป็นอินพุต ในการดำเนินการนี้ความเข้มระดับสีเทาของจุดภายในพื้นที่เบื้องหน้าจะเปลี่ยนเป็นระยะห่างตามลำดับจากค่า 0 ที่ใกล้เคียงที่สุด (ขอบเขต)

    คุณสามารถใช้การแปลงระยะทางใน OpenCV โดยใช้วิธีการ distanceTransform(). ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

    distanceTransform(src, dst, distanceType, maskSize)

    วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

    • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

    • dst - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

    • distanceType - ตัวแปรประเภทจำนวนเต็มแทนประเภทของการแปลงระยะทางที่จะนำไปใช้

    • maskSize - ตัวแปรประเภทจำนวนเต็มแทนขนาดมาสก์ที่จะใช้

    ตัวอย่าง

    โปรแกรมต่อไปนี้สาธิตวิธีดำเนินการแปลงระยะทางบนภาพที่กำหนด

    import org.opencv.core.Core;
    import org.opencv.core.Mat;
    import org.opencv.imgcodecs.Imgcodecs;
    import org.opencv.imgproc.Imgproc;
    
    public class DistanceTransform {
       public static void main(String args[]) {
          // Loading the OpenCV core library
          System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
    
          // Reading the Image from the file and storing it in to a Matrix object
          String file ="E:/OpenCV/chap19/input.jpg";
          Mat src = Imgcodecs.imread(file,0);
    
          // Creating an empty matrix to store the results
          Mat dst = new Mat();
          Mat binary = new Mat();
    
          // Converting the grayscale image to binary image
          Imgproc.threshold(src, binary, 100, 255, Imgproc.THRESH_BINARY);
    
          // Applying distance transform
          Imgproc.distanceTransform(mat, dst, Imgproc.DIST_C, 3);
    
          // Writing the image
          Imgcodecs.imwrite("E:/OpenCV/chap19/distnceTransform.jpg", dst);
    
          System.out.println("Image Processed");
       }
    }

สมมติว่าต่อไปนี้เป็นภาพอินพุต input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

ประเภทของการดำเนินการแปลงระยะทาง

นอกเหนือจากประเภทการทำงานของระยะทาง DIST_Cแสดงให้เห็นในตัวอย่างก่อนหน้านี้ OpenCV รองรับการดำเนินการแปลงระยะทางประเภทอื่น ๆ ประเภททั้งหมดเหล่านี้แสดงโดยฟิลด์คงที่ที่กำหนดไว้ล่วงหน้า (ค่าคงที่) ของคลาส Imgproc

คุณสามารถเลือกประเภทของการดำเนินการแปลงระยะทางที่คุณต้องการโดยส่งผ่านค่าที่กำหนดไว้ล่วงหน้าตามลำดับไปยังพารามิเตอร์ที่ชื่อ distanceType ของ distanceTransform() วิธี.

// Applying distance transform 
Imgproc.distanceTransform(mat, dst, Imgproc.DIST_C, 3);

ต่อไปนี้เป็นค่าที่แสดงถึงประเภทต่างๆ distanceTransform การดำเนินงานและผลลัพธ์ตามลำดับ

การทำงานและคำอธิบาย เอาต์พุต
DIST_C
DIST_L1
DIST_L2
DIST_LABEL_PIXEL
DIST_MASK_3

ในบทนี้เราจะเรียนรู้วิธีใช้ OpenCV เพื่อจับภาพเฟรมโดยใช้กล้องระบบ VideoCapture คลาสของ org.opencv.videoioแพ็คเกจประกอบด้วยคลาสและวิธีการจับภาพวิดีโอโดยใช้กล้อง ไปทีละขั้นตอนและเรียนรู้วิธีจับภาพเฟรม -

ขั้นตอนที่ 1: โหลดไลบรารีเนทีฟ OpenCV

ในขณะที่เขียนโค้ด Java โดยใช้ไลบรารี OpenCV ขั้นตอนแรกที่คุณต้องทำคือโหลดไลบรารีดั้งเดิมของ OpenCV โดยใช้ loadLibrary(). โหลดไลบรารีเนทีฟ OpenCV ดังที่แสดงด้านล่าง

// Loading the core library 
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

ขั้นตอนที่ 2: เริ่มคลาสการจับภาพวิดีโอ

สร้างอินสแตนซ์คลาส Mat โดยใช้ฟังก์ชันใด ๆ ที่กล่าวถึงในบทช่วยสอนนี้ก่อนหน้านี้

// Instantiating the VideoCapture class (camera:: 0) 
VideoCapture capture = new VideoCapture(0);

ขั้นตอนที่ 3: อ่านเฟรม

คุณสามารถอ่านเฟรมจากกล้องได้โดยใช้ไฟล์ read() วิธีการของ VideoCaptureชั้นเรียน วิธีนี้ยอมรับวัตถุของคลาสMat เพื่อจัดเก็บเฟรมที่อ่าน

// Reading the next video frame from the camera 
Mat matrix = new Mat(); 
capture.read(matrix);

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการจับเฟรมโดยใช้กล้องและแสดงโดยใช้หน้าต่าง JavaFX นอกจากนี้ยังบันทึกเฟรมที่จับได้

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.WritableRaster;

import java.io.FileNotFoundException;
import java.io.IOException;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.videoio.VideoCapture;

public class CameraSnapshotJavaFX extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws FileNotFoundException, IOException {
      // Capturing the snapshot from the camera
      CameraSnapshotJavaFX obj = new CameraSnapshotJavaFX();
      WritableImage writableImage = obj.capureSnapShot();

      // Saving the image
      obj.saveImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Capturing an image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage capureSnapShot() {
      WritableImage WritableImage = null;

      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the VideoCapture class (camera:: 0)
      VideoCapture capture = new VideoCapture(0);

      // Reading the next video frame from the camera
      Mat matrix = new Mat();
      capture.read(matrix);

      // If camera is opened
      if( capture.isOpened()) {
         // If there is next video frame
         if (capture.read(matrix)) {
            // Creating BuffredImage from the matrix
            BufferedImage image = new BufferedImage(matrix.width(), 
               matrix.height(), BufferedImage.TYPE_3BYTE_BGR);
            
            WritableRaster raster = image.getRaster();
            DataBufferByte dataBuffer = (DataBufferByte) raster.getDataBuffer();
            byte[] data = dataBuffer.getData();
            matrix.get(0, 0, data);
            this.matrix = matrix;
            
            // Creating the Writable Image
            WritableImage = SwingFXUtils.toFXImage(image, null);
         }
      }
      return WritableImage;
   }
   public void saveImage() {
      // Saving the Image
      String file = "E:/OpenCV/chap22/sanpshot.jpg";

      // Instantiating the imgcodecs class
      Imgcodecs imageCodecs = new Imgcodecs();

      // Saving it again 
      imageCodecs.imwrite(file, matrix);
   }
   public static void main(String args[]) {
      launch(args);
   }
}

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตเห็นเฟรมเดียวกันซึ่งบันทึกเป็นไฟล์ jpg

VideoCapture คลาสของ org.opencv.videoioแพ็คเกจประกอบด้วยคลาสและวิธีการจับภาพวิดีโอโดยใช้กล้องระบบ ไปทีละขั้นตอนและเรียนรู้วิธีการทำ

ขั้นตอนที่ 1: โหลดไลบรารีเนทีฟ OpenCV

ในขณะที่เขียนโค้ด Java โดยใช้ไลบรารี OpenCV ขั้นตอนแรกที่คุณต้องทำคือโหลดไลบรารีดั้งเดิมของ OpenCV โดยใช้ loadLibrary(). โหลดไลบรารีเนทีฟ OpenCV ดังที่แสดงด้านล่าง

// Loading the core library 
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

ขั้นตอนที่ 2: สร้างอินสแตนซ์คลาส CascadeClassifier

CascadeClassifier คลาสของแพ็คเกจ org.opencv.objdetectใช้เพื่อโหลดไฟล์ลักษณนาม สร้างอินสแตนซ์คลาสนี้โดยส่งไฟล์xml ไฟล์ lbpcascade_frontalface.xml ดังแสดงด้านล่าง

// Instantiating the CascadeClassifier 
String xmlFile = "E:/OpenCV/facedetect/lbpcascade_frontalface.xml"; 
CascadeClassifier classifier = new CascadeClassifier(xmlFile);

ขั้นตอนที่ 3: ตรวจจับใบหน้า

คุณสามารถตรวจจับใบหน้าในภาพได้โดยใช้วิธี detectMultiScale() ของคลาสชื่อ CascadeClassifier. วิธีนี้ยอมรับวัตถุของคลาสMat ถือภาพอินพุตและวัตถุของคลาส MatOfRect เพื่อจัดเก็บใบหน้าที่ตรวจพบ

// Detecting the face in the snap 
MatOfRect faceDetections = new MatOfRect(); 
classifier.detectMultiScale(src, faceDetections);

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีตรวจจับใบหน้าในภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
  
public class FaceDetectionImage {
   public static void main (String[] args) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap23/facedetection_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Instantiating the CascadeClassifier
      String xmlFile = "E:/OpenCV/facedetect/lbpcascade_frontalface.xml";
      CascadeClassifier classifier = new CascadeClassifier(xmlFile);

      // Detecting the face in the snap
      MatOfRect faceDetections = new MatOfRect();
      classifier.detectMultiScale(src, faceDetections);
      System.out.println(String.format("Detected %s faces", 
         faceDetections.toArray().length));

      // Drawing boxes for (Rect rect : faceDetections.toArray()) { Imgproc.rectangle( src, // where to draw the box new Point(rect.x, rect.y), // bottom left new Point(rect.x + rect.width, rect.y + rect.height), // top right new Scalar(0, 0, 255), 3 // RGB colour );
      }

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap23/facedetect_output1.jpg", src);

      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต facedetection_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Detected 3 faces 
Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

โปรแกรมต่อไปนี้สาธิตวิธีตรวจจับใบหน้าโดยใช้กล้องระบบและแสดงโดยใช้หน้าต่าง JavaFX

ตัวอย่าง

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.WritableRaster;

import java.io.FileNotFoundException;
import java.io.IOException;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
import org.opencv.videoio.VideoCapture;

public class faceDetectionJavaFXX extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws FileNotFoundException, IOException {
      // Capturing the snapshot from the camera
      faceDetectionJavaFXX obj = new faceDetectionJavaFXX();
      WritableImage writableImage = obj.capureFrame();

      // Saving the image
      obj.saveImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Capturing an image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage capureFrame() {
      WritableImage writableImage = null;

      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the VideoCapture class (camera:: 0)
      VideoCapture capture = new VideoCapture(0);

      // Reading the next video frame from the camera
      Mat matrix = new Mat();
      capture.read(matrix);

      // If camera is opened
      if(!capture.isOpened()) {
         System.out.println("camera not detected");
      } else
         System.out.println("Camera detected ");
           
      // If there is next video frame
      if (capture.read(matrix)) {
         /////// Detecting the face in the snap /////
         String file = "E:/OpenCV/facedetect/lbpcascade_frontalface.xml";
         CascadeClassifier classifier = new CascadeClassifier(file);

         MatOfRect faceDetections = new MatOfRect();
         classifier.detectMultiScale(matrix, faceDetections);
         System.out.println(String.format("Detected %s faces",
            faceDetections.toArray().length));

         // Drawing boxes for (Rect rect : faceDetections.toArray()) { Imgproc.rectangle( matrix, //where to draw the box new Point(rect.x, rect.y), //bottom left new Point(rect.x + rect.width, rect.y + rect.height), //top right new Scalar(0, 0, 255) //RGB colour );
         }
         // Creating BuffredImage from the matrix
         BufferedImage image = new BufferedImage(matrix.width(), matrix.height(),
            BufferedImage.TYPE_3BYTE_BGR);
         
         WritableRaster raster = image.getRaster();
         DataBufferByte dataBuffer = (DataBufferByte) raster.getDataBuffer();
         byte[] data = dataBuffer.getData();
         matrix.get(0, 0, data);

         this.matrix = matrix;
           
         // Creating the Writable Image
         writableImage = SwingFXUtils.toFXImage(image, null);
      }
      return writableImage;
   }
   public void saveImage() {
      // Saving the Image
      String file = "E:/OpenCV/chap23/facedetected.jpg";

      // Instantiating the imagecodecs class
      Imgcodecs imageCodecs = new Imgcodecs();

      // Saving it again
      imageCodecs.imwrite(file, matrix);
   }
   public static void main(String args[]) {
      launch(args);
   }
}

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้

หากคุณเปิดเส้นทางที่ระบุคุณจะเห็นสแนปชอตเดียวกันที่บันทึกเป็นไฟล์ jpg ภาพ.

คุณสามารถดำเนินการ affine translation บนภาพโดยใช้ warpAffine()วิธีการของคลาส imgproc ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

Imgproc.warpAffine(src, dst, tranformMatrix, size);

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • tranformMatrix - ก Mat วัตถุแทนเมทริกซ์การเปลี่ยนแปลง

  • size - ตัวแปรประเภทจำนวนเต็มแทนขนาดของภาพที่ส่งออก

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีใช้การดำเนินการ Affine กับรูปภาพที่กำหนด

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.Point;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class AffineTranslation {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap24/transform_input.jpg";
      Mat src = Imgcodecs.imread(file);

      //Creating an empty matrix to store the result
      Mat dst = new Mat();

      Point p1 = new Point( 0,0 );
      Point p2 = new Point( src.cols() - 1, 0 );
      Point p3 = new Point( 0, src.rows() - 1 );
      Point p4 = new Point( src.cols()*0.0, src.rows()*0.33 );
      Point p5 = new Point( src.cols()*0.85, src.rows()*0.25 );
      Point p6 = new Point( src.cols()*0.15, src.rows()*0.7 );
      
      MatOfPoint2f ma1 = new MatOfPoint2f(p1,p2,p3);
      MatOfPoint2f ma2 = new MatOfPoint2f(p4,p5,p6);

      // Creating the transformation matrix
      Mat tranformMatrix = Imgproc.getAffineTransform(ma1,ma2);

      // Creating object of the class Size
      Size size = new Size(src.cols(), src.cols());

      // Applying Wrap Affine
      Imgproc.warpAffine(src, dst, tranformMatrix, size);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap24/Affinetranslate.jpg", dst);

      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต transform_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

คุณสามารถ perform rotation การทำงานกับภาพโดยใช้ไฟล์ warpAffine() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

Imgproc.warpAffine(src, dst, rotationMatrix, size);

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • rotationMatrix - ก Mat วัตถุแทนเมทริกซ์การหมุน

  • size - ตัวแปรประเภทจำนวนเต็มแทนขนาดของภาพที่ส่งออก

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการหมุนภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Size;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class Rotation {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap24/transform_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating a Point object
      Point point = new Point(300, 200)

      // Creating the transformation matrix M
      Mat rotationMatrix = Imgproc.getRotationMatrix2D(point, 30, 1);

      // Creating the object of the class Size
      Size size = new Size(src.cols(), src.cols());

      // Rotating the given image
      Imgproc.warpAffine(src, dst, rotationMatrix, size);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap24/rotate_output.jpg", dst);

      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต transform_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

คุณสามารถดำเนินการ scaling บนภาพโดยใช้ resize() วิธีการของ imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • dst - ก Mat อ็อบเจ็กต์ที่แสดงปลายทาง (รูปภาพเอาต์พุต) สำหรับการดำเนินการนี้

  • dsize - ก Size วัตถุแทนขนาดของภาพที่ส่งออก

  • fx - ตัวแปรประเภท double ที่แสดงถึงตัวคูณมาตราส่วนตามแกนแนวนอน

  • fy - ตัวแปรประเภท double ที่แสดงถึงตัวคูณมาตราส่วนตามแกนแนวตั้ง

  • Interpolation - ตัวแปรจำนวนเต็มแทนวิธีการแก้ไข

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการสมัคร scale transformation ไปยังรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class Scaling {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap24/transform_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating the Size object
      Size size = new Size(src.rows()*2, src.rows()*2);

      // Scaling the Image
      Imgproc.resize(src, dst, size, 0, 0, Imgproc.INTER_AREA);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap24/scale_output.jpg", dst);

      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต transform_input.jpg ระบุไว้ในโปรแกรมด้านบน (ขนาด - กว้าง: 300px และสูง: 300px)

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ (ขนาด - ความกว้าง: 600px และความสูง: 600px) -

ใน OpenCV คุณสามารถใช้แผนที่สีต่างๆกับรูปภาพได้โดยใช้วิธี applyColorMap() ของชั้นเรียน Imgproc. ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้ -

applyColorMap(Mat src, Mat dst, int colormap)

ยอมรับสามพารามิเตอร์ -

  • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

  • dst - วัตถุของคลาส Mat แสดงภาพปลายทาง (เอาต์พุต)

  • colormap - ตัวแปรประเภทจำนวนเต็มแทนชนิดของแผนที่สีที่จะนำไปใช้

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีการสมัคร color map ไปยังรูปภาพ

import org.opencv.core.Core;
import org.opencv.core.Mat;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class ColorMapTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap25/color_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying color map to an image
      Imgproc.applyColorMap(src, dst, Imgproc.COLORMAP_HOT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap25/colormap_hot.jpg", dst);
      System.out.println("Image processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต color_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

การดำเนินงานเพิ่มเติม

นอกจาก COLORMAP_HOTแสดงให้เห็นในตัวอย่างก่อนหน้านี้ OpenCV ให้บริการแผนที่สีประเภทอื่น ๆ ประเภททั้งหมดเหล่านี้แสดงโดยฟิลด์คงที่ที่กำหนดไว้ล่วงหน้า (ค่าคงที่) ของคลาส Imgproc

คุณสามารถเลือกประเภทของ colormap ที่คุณต้องการได้โดยส่งค่าที่กำหนดไว้ล่วงหน้าตามลำดับไปยังพารามิเตอร์ที่ชื่อ colormap ของ applyColorMap() วิธี.

Imgproc.applyColorMap(src, dst, Imgproc.COLORMAP_HOT);

ต่อไปนี้เป็นค่าที่แสดงถึงประเภทต่างๆของแผนที่สีและผลลัพธ์ตามลำดับ

การทำงานและคำอธิบาย เอาต์พุต
COLORMAP_AUTUMN
COLORMAP_BONE
COLORMAP_COOL
COLORMAP_HOT
COLORMAP_HSV
COLORMAP_JET
COLORMAP_OCEAN
COLORMAP_PARULA
COLORMAP_PINK
COLORMAP_RAINBOW
COLORMAP_SPRING
COLORMAP_SUMMER
COLORMAP_WINTER

Canny Edge Detection ใช้เพื่อตรวจจับขอบในภาพ ยอมรับภาพสเกลสีเทาเป็นอินพุตและใช้อัลกอริทึมหลายขั้นตอน

คุณสามารถดำเนินการนี้กับรูปภาพโดยใช้ไฟล์ Canny() วิธีการของ imgproc คลาสต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

Canny(image, edges, threshold1, threshold2)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • image - ก Mat วัตถุแทนแหล่งที่มา (ภาพอินพุต) สำหรับการดำเนินการนี้

  • edges - ก Mat วัตถุแทนปลายทาง (ขอบ) สำหรับการดำเนินการนี้

  • threshold1 - ตัวแปรประเภท double ที่แสดงถึง threshold แรกสำหรับขั้นตอน hysteresis

  • threshold2 - ตัวแปรประเภท double ที่แสดงถึงขีดที่สองสำหรับขั้นตอน hysteresis

ตัวอย่าง

โปรแกรมต่อไปนี้เป็นตัวอย่างการสาธิตวิธีดำเนินการ Canny Edge Detection บนภาพที่กำหนด

import org.opencv.core.Core;
import org.opencv.core.Mat;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class CannyEdgeDetection {
   public static void main(String args[]) throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      // Reading the Image from the file and storing it in to a Matrix object
      String file = "E:/OpenCV/chap17/canny_input.jpg";

      // Reading the image
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat gray = new Mat();

      // Converting the image from color to Gray
      Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
      Mat edges = new Mat();

      // Detecting the edges
      Imgproc.Canny(gray, edges, 60, 60*3);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap17/canny_output.jpg", edges);
      System.out.println("Image Loaded");
   } 
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต canny_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

คุณสามารถตรวจจับรูปร่างของรูปภาพที่กำหนดได้โดยใช้ไฟล์ Hough Transform technique โดยใช้วิธีการ HoughLines() ของ Imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

HoughLines(image, lines, rho, theta, threshold)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • image - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

  • lines - วัตถุของคลาส Mat ที่เก็บเวกเตอร์ที่เก็บพารามิเตอร์ (r, Φ) ของเส้น

  • rho - ตัวแปรประเภท double ที่แสดงความละเอียดของพารามิเตอร์ r เป็นพิกเซล

  • theta - ตัวแปรประเภท double แสดงความละเอียดของพารามิเตอร์Φเป็นเรเดียน

  • threshold - ตัวแปรประเภทจำนวนเต็มแทนจำนวนจุดตัดต่ำสุดในการ "ตรวจหา" เส้น

ตัวอย่าง

โปรแกรมต่อไปนี้สาธิตวิธีตรวจจับเส้น Hough ในภาพที่กำหนด

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Scalar;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class HoughlinesTest {
   public static void main(String args[]) throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file = "E:/OpenCV/chap21/hough_input.jpg";

      // Reading the image
      Mat src = Imgcodecs.imread(file,0);

      // Detecting edges of it
      Mat canny = new Mat();
      Imgproc.Canny(src, canny, 50, 200, 3, false);

      // Changing the color of the canny
      Mat cannyColor = new Mat();
      Imgproc.cvtColor(canny, cannyColor, Imgproc.COLOR_GRAY2BGR);

      // Detecting the hough lines from (canny)
      Mat lines = new Mat();
      Imgproc.HoughLines(canny, lines, 1, Math.PI/180, 100);

      System.out.println(lines.rows());
      System.out.println(lines.cols());

      // Drawing lines on the image
      double[] data;
      double rho, theta;
      Point pt1 = new Point();
      Point pt2 = new Point();
      double a, b;
      double x0, y0;
      
      for (int i = 0; i < lines.cols(); i++) {
         data = lines.get(0, i);
         rho = data[0];
         theta = data[1];
         
         a = Math.cos(theta);
         b = Math.sin(theta);
         x0 = a*rho;
         y0 = b*rho;
         
         pt1.x = Math.round(x0 + 1000*(-b));
         pt1.y = Math.round(y0 + 1000*(a));
         pt2.x = Math.round(x0 - 1000*(-b));
         pt2.y = Math.round(y0 - 1000 *(a));
         Imgproc.line(cannyColor, pt1, pt2, new Scalar(0, 0, 255), 6);
      }
      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap21/hough_output.jpg", cannyColor);
          
      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต hough_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

143 
1 
Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -

histogramของภาพแสดงความถี่ของค่าความเข้มของพิกเซล ในฮิสโตแกรมรูปภาพแกน X จะแสดงความเข้มของระดับสีเทาและแกน Y จะแสดงความถี่ของความเข้มเหล่านี้

Histogram equalizationปรับปรุงคอนทราสต์ของภาพเพื่อยืดช่วงอินเทนสตี้ออกไป คุณสามารถทำให้ฮิสโตแกรมของรูปภาพนั้นเท่ากันได้โดยใช้วิธีนี้equalizeHist() ของ Imgprocชั้นเรียน ต่อไปนี้เป็นไวยากรณ์ของวิธีนี้

equalizeHist(src, dst)

วิธีนี้ยอมรับพารามิเตอร์ต่อไปนี้ -

  • src - วัตถุของคลาส Mat แสดงภาพแหล่งที่มา (อินพุต)

  • dst - วัตถุของคลาส Matแสดงผลลัพธ์ (ภาพที่ได้หลังจากปรับค่าฮิสโตแกรมให้เท่ากัน)

ตัวอย่าง

โปรแกรมต่อไปนี้จะสาธิตวิธีการปรับฮิสโตแกรมของรูปภาพที่กำหนดให้เท่ากัน

import java.util.ArrayList;
import java.util.List;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class HistoTest {
   public static void main (String[] args) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap20/histo_input.jpg";

      // Load the image
      Mat img = Imgcodecs.imread(file);

      // Creating an empty matrix
      Mat equ = new Mat();
      img.copyTo(equ);

      // Applying blur
      Imgproc.blur(equ, equ, new Size(3, 3));

      // Applying color
      Imgproc.cvtColor(equ, equ, Imgproc.COLOR_BGR2YCrCb);
      List<Mat> channels = new ArrayList<Mat>();

      // Splitting the channels
      Core.split(equ, channels);

      // Equalizing the histogram of the image
      Imgproc.equalizeHist(channels.get(0), channels.get(0));
      Core.merge(channels, equ);
      Imgproc.cvtColor(equ, equ, Imgproc.COLOR_YCrCb2BGR);

      Mat gray = new Mat();
      Imgproc.cvtColor(equ, gray, Imgproc.COLOR_BGR2GRAY);
      Mat grayOrig = new Mat();
      Imgproc.cvtColor(img, grayOrig, Imgproc.COLOR_BGR2GRAY);

      Imgcodecs.imwrite("E:/OpenCV/chap20/histo_output.jpg", equ);
      System.out.println("Image Processed");
   }
}

สมมติว่าต่อไปนี้เป็นภาพอินพุต histo_input.jpg ระบุไว้ในโปรแกรมข้างต้น

เอาต์พุต

ในการรันโปรแกรมคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Image Processed

หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -