Merge pull request #5 from MicrochipTech/release2023.2

Pushing for 2023.2 release

Author: Alireza-Mellat

vision/README.md

@@ -48,7 +48,7 @@ Please see the readme files in sub-directories for more details.
 
 - To use the SmartHLS Vision library, you should first install the SmartHLS tool, which is part of the [Libero SoC Design Suite](https://www.microchip.com/en-us/products/fpgas-and-plds/fpga-and-soc-design-tools/fpga/libero-software-later-versions).
 
-  `Note: This library is designed to work on the latest Libero SoC Design Suite version, 2023.1, and may not be compatible with previous versions of Libero and SmartHLS.`
+  `Note: This library is designed to work on the latest Libero SoC Design Suite version, 2023.2, and may not be compatible with previous versions of Libero and SmartHLS.`
 
 - The repository uses Git Large File System (LFS) to track media files (e.g., images). So we need to install Git LFS.
   - First make sure you have Git and Git LFS installed. If not, you can follow this instruction: https://github.com/git-guides/install-git
@@ -69,7 +69,7 @@ Please see the readme files in sub-directories for more details.
 - The SmartHLS Vision library supports using OpenCV functionality in the software testbench of a SmartHLS project.
   So we will also download a precompiled OpenCV library using a provided script (see [here](https://microchiptech.github.io/fpga-hls-docs/precompiled_sw.html#ffmpeg-4-4-and-opencv-4-5-4) for more details):
   ```console
-  > /cygdrive/c/Microchip/Libero_SoC_v2023.1/SmartHLS-2023.1/SmartHLS/examples/scripts/utils/download_libraries.sh
+  > /cygdrive/c/Microchip/Libero_SoC_v2023.2/SmartHLS-2023.2/SmartHLS/examples/scripts/utils/download_libraries.sh
   ```
 
 ## Getting Started

vision/demo_designs/PF_Video_kit/README.md

@@ -1,12 +1,12 @@
 SRCS=pf_demo.cpp
 LOCAL_CONFIG = -legup-config=config.tcl
-LEVEL = $(LEGUP_ROOT_DIR)/examples
+LEVEL = $(SHLS_ROOT_DIR)/examples
 
 ifeq ($(shell uname -o), Cygwin)
 # Use cygpath to locate the Windows location
-OPENCV_PATH := $(shell cygpath -t mixed $(LEGUP_ROOT_DIR)/precompiled_sw_libraries/opencv4.5.4-x86_64-cygwin)
+OPENCV_PATH := $(shell cygpath -t mixed $(SHLS_ROOT_DIR)/precompiled_sw_libraries/opencv4.5.4-x86_64-cygwin)
 else
-OPENCV_PATH := $(LEGUP_ROOT_DIR)/precompiled_sw_libraries/opencv4.5.4-x86_64-linux
+OPENCV_PATH := $(SHLS_ROOT_DIR)/precompiled_sw_libraries/opencv4.5.4-x86_64-linux
 endif
 
 USER_CXX_FLAG += -I$(OPENCV_PATH)/include/opencv4

vision/demo_designs/PF_Video_kit/doc_images/PFVideoKitDemoDiagram.png

@@ -1,4 +1,4 @@
-source $env(LEGUP_ROOT_DIR)/examples/legup.tcl
+source $env(SHLS_ROOT_DIR)/examples/legup.tcl
 set_project PolarFire MPF300 hw_only
 # set_project PolarFireSoC MPFS250T MiV_SoC
 

vision/demo_designs/PF_Video_kit/doc_images/pf_demo_sd.png

@@ -0,0 +1 @@
+../../../media_files/test_images/demo_golden.png

vision/demo_designs/PF_Video_kit/hls/Makefile

@@ -21,100 +21,98 @@ using vision::PixelType::HLS_8UC3;
 
 // Define data types used in the design.
 using BayerAxisVideoT = vision::AxisVideoFIFO<HLS_8UC1, NPPC_4>;
-using RgbAxisVideoT = vision::AxisVideoFIFO<HLS_8UC3, NPPC_4>;
+using RGBAxisVideoT = vision::AxisVideoFIFO<HLS_8UC3, NPPC_4>;
 using BayerImgT =
     vision::Img<HLS_8UC1, HEIGHT, WIDTH, StorageType::FIFO, NPPC_4>;
-using RgbImgT = vision::Img<HLS_8UC3, HEIGHT, WIDTH, StorageType::FIFO, NPPC_4>;
-
-// The following 3 top functions are compiled to RTL and are used on board:
-void DDR_Read_wrapper(uint64_t *Buf, BayerAxisVideoT &VideoOut, int HRes,
-                      int VRes) {
-#pragma HLS function top dataflow
-#pragma HLS interface argument(Buf) type(axi_initiator)                        \
-    num_elements(NumAxiWords) max_burst_len(256)
-
-    vision::AxiMM2AxisVideo<AxiWordWidth, uint64_t, HEIGHT, WIDTH>(
-        Buf, VideoOut, HRes, VRes);
-}
+using RGBImgT = vision::Img<HLS_8UC3, HEIGHT, WIDTH, StorageType::FIFO, NPPC_4>;
+using GrayImgT =
+    vision::Img<HLS_8UC1, HEIGHT, WIDTH, StorageType::FIFO, NPPC_4>;
 
+// The following 2 top functions are compiled to RTL and are used on board:
 void DDR_Write_wrapper(BayerAxisVideoT &VideoIn, uint64_t *Buf, int HRes,
                        int VRes) {
-#pragma HLS function top dataflow
+#pragma HLS function top
 #pragma HLS interface argument(Buf) type(axi_initiator)                        \
     num_elements(NumAxiWords) max_burst_len(256)
 
     vision::AxisVideo2AxiMM<AxiWordWidth, uint64_t, HEIGHT, WIDTH>(VideoIn, Buf,
                                                                    HRes, VRes);
 }
 
-void VideoPipelineTop(BayerAxisVideoT &VideoIn, RgbAxisVideoT &VideoOut,
+void VideoPipelineTop(uint64_t *Buf, RGBAxisVideoT &VideoOut,
                       ap_uint<2> BayerFormat = 0) {
 #pragma HLS function top
 #pragma HLS function dataflow
+#pragma HLS interface argument(Buf) type(axi_initiator)                        \
+    num_elements(NumAxiWords) max_burst_len(256)
     BayerImgT BayerImg;
-    RgbImgT RGBImage;
-    vision::AxisVideo2Img(VideoIn, BayerImg);
-    vision::DeBayer(BayerImg, RGBImage, BayerFormat);
-    vision::Img2AxisVideo(RGBImage, VideoOut);
+    RGBImgT RGBInImg, RGBOutImg;
+    GrayImgT GSImg, CannyImg;
+    unsigned Thres = 110;
+
+    vision::AxiMM2Img<AxiWordWidth>(Buf, BayerImg);
+    vision::DeBayer(BayerImg, RGBInImg, BayerFormat);
+    vision::RGB2GRAY(RGBInImg, GSImg);
+    vision::Canny(GSImg, CannyImg, Thres);
+    vision::GRAY2RGB(CannyImg, RGBOutImg);
+    vision::Img2AxisVideo(RGBOutImg, VideoOut);
 }
 
 // This main implements a testbench verifying the above top-level functions.
 int main() {
     // Step 1: create the input to top-level functions.
-    // - generate an RGB image using pattern generator
-    // - convert the image to Bayer format
-    // - then inject the image into an AXI-S video protocol stream.
+    // - Read an RGB image
+    // - Convert the image to Bayer format
+    // - Then inject the image into an AXI-S video protocol stream.
     // The resulting pixel stream is similar to the input data coming from the
     // camera module on board.
-    RgbImgT PatternImg;
-    BayerImgT BayerImgIn;
-    BayerAxisVideoT InputStream(NumPixelWords), DDRReadFIFO(NumPixelWords);
-    vision::PatternGenerator<3>(PatternImg);
-    vision::RGB2Bayer(PatternImg, BayerImgIn);
-    vision::Img2AxisVideo(BayerImgIn, InputStream);
+    RGBImgT InImg;
+    BayerImgT BayerInImg;
+    BayerAxisVideoT InStream(NumPixelWords), DDRReadFIFO(NumPixelWords);
+    Mat BGRInMat = cv::imread("toronto_4k.jpg", cv::IMREAD_COLOR);
+    Mat RGBInMat;
+    cv::cvtColor(BGRInMat, RGBInMat, cv::COLOR_BGR2RGB);
+
+    // Convert the cv Mat into Img class
+    convertFromCvMat(RGBInMat, InImg);
+    vision::RGB2Bayer(InImg, BayerInImg);
+    vision::Img2AxisVideo(BayerInImg, InStream);
 
     // Step 2: pass the input to the top-level functions and obtain the output.
-    // The InputStream is fed to DDR write and read functions, which write
-    // incoming data to DDR and read it back.
-    // The data read from DDR is then forwarded to the video pipeline which does
-    // DeBayer on the incoming data and outputs data in RGB format.
+    // The InStream is fed to DDR write function, which writes incoming data
+    // to DDR.
+    // The video pipeline reads data from DDR and does DeBayer, RGB2Gray, Canny,
+    // Gray2RGB, and outputs data in RGB format.
 
-    // Intermediate data between DDR writer and DDR reader. You can think of it
-    // as the DDR memory. 'static' so we don't get stack overflow.
+    // Intermediate data between DDR writer and video pipeline. You can think of
+    // it as the DDR memory. 'static' so we don't get stack overflow.
     static uint64_t Buf[NumPixelWords];
     // Output from
-    RgbAxisVideoT OutputStream(NumPixelWords);
-    // Call the three top-level funtions.
-    DDR_Write_wrapper(InputStream, Buf, WIDTH, HEIGHT);
-    DDR_Read_wrapper(Buf, DDRReadFIFO, WIDTH, HEIGHT);
-    VideoPipelineTop(DDRReadFIFO, OutputStream, 0);
-
+    RGBAxisVideoT OutputStream(NumPixelWords);
+    // Call the two top-level functions.
+    DDR_Write_wrapper(InStream, Buf, WIDTH, HEIGHT);
+    VideoPipelineTop(Buf, OutputStream, 0);
     // Step 3: verify the output data by comparing against an expected image.
 
     // Convert OutputStream to `vision::Img` type and then to `cv::Mat` type.
-    RgbImgT OutImg;
+    RGBImgT OutImg;
     vision::AxisVideo2Img(OutputStream, OutImg);
     cv::Mat HlsOutMat;
     convertToCvMat(OutImg, HlsOutMat);
+    cv::imwrite("hls_out.png", HlsOutMat);
 
-    // Create the golden output Mat with the same pattern as above input image.
-    RgbImgT GoldenImg;
-    vision::PatternGenerator<3>(GoldenImg);
-    cv::Mat GoldenMat;
-    convertToCvMat(GoldenImg, GoldenMat);
+    // Read the golden image
+    Mat GoldenMat = cv::imread("demo_golden.png", cv::IMREAD_COLOR);
+    Mat GoldenRGBMat;
+    cv::cvtColor(GoldenMat, GoldenRGBMat, cv::COLOR_BGR2RGB);
 
     // Now compare the two Mat's, with a threshold of 0 (any pixel with
     // difference in value will be considered as an error).
-    // Use this commented out line to report location of errors.
-    //   vision::compareMatAndReport<cv::Vec3b>(HlsOutMat, GoldenMat, 0);
-    float ErrPercent = vision::compareMat(HlsOutMat, GoldenMat, 0);
-    printf("Percentage of pixels with difference over threshold: %0.2lf%\n",
-           ErrPercent);
-
-    // Consider the test passes if there is less than 1% of pixels in
-    // difference.
-    bool Pass = (ErrPercent < 1.f);
-    printf("%s\n", Pass ? "PASS" : "FAIL");
 
+    // Use this commented out line to report location of errors.
+    // vision::compareMatAndReport<cv::Vec3b>(HlsOutMat, GoldenRGBMat, 0);
+    float ErrPercent = vision::compareMat(HlsOutMat, GoldenRGBMat, 0);
+    bool Pass = (ErrPercent == 0.0);
+    printf("%s\n", Pass ? "Pass" : "Fail");
     return Pass ? 0 : 1; // Only return 0 on pass.
 }

vision/demo_designs/PF_Video_kit/hls/config.tcl

@@ -0,0 +1 @@
+../../PF_Video_kit/../../media_files/toronto_4k.jpg

vision/demo_designs/PF_Video_kit/hls/demo_golden.png

@@ -5,7 +5,6 @@ new_project -location {./vision_pipeline} -name {vision_pipeline} -project_descr
 source ../../../rtl/ip_core_versions.tcl
 
 #Download all the required cores to the vault (Camera and display components will download their required cores separately)
-download_core -vlnv "Microsemi:SolutionCore:Display_Controller:${Display_Controller_version}"  -location {www.microchip-ip.com/repositories/DirectCore}
 download_core -vlnv "Actel:SystemBuilder:PF_DDR4:${PF_DDR4_version}" -location {www.microchip-ip.com/repositories/SgCore}
 download_core -vlnv "Actel:SystemBuilder:PF_SRAM_AHBL_AXI:${PF_SRAM_AHBL_AXI_version}" -location {www.microchip-ip.com/repositories/SgCore}
 download_core -vlnv "Actel:DirectCore:COREI2C:${COREI2C_version}" -location {www.microchip-ip.com/repositories/DirectCore}