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 - เปิดโฟลเดอร์ OpenCV → build → java. ที่นี่คุณจะพบไฟล์ 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 และไปที่โฟลเดอร์ย่อย build → java. ที่นี่คุณจะพบสองโฟลเดอร์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อีเจียน Oฉ Interest. |
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 Loadedwrite() วิธีการของ 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หากคุณเปิดเส้นทางที่ระบุคุณสามารถสังเกตภาพที่ส่งออกได้ดังนี้ -
