Vitis Accelerated Libraries

https://github.com/xilinx/vitis_libraries
Admin
Vitis Accelerated Libraries is a comprehensive set of open-source, performance-optimized libraries...
Tokens:415,579
Snippets:2,766
Trust Score:9.3
License:Apache-2.0
Update:9 months ago
Show doc for...
Tokens:
Raw
### Change Directory to Houghlines Example

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/houghlines-bm.rst

Navigates the user to the 'L2/examples/houghlines' directory to begin the setup process for the Houghlines benchmark. This is the initial step before proceeding with build commands.

```bash
cd L2/example/houglines
```

--------------------------------

### Setup Vitis Environment and Clone Vitis Libraries

Source: https://github.com/xilinx/vitis_libraries/blob/main/motor_control/docs/src/tutorial.rst

This snippet outlines the shell commands to set up the Vitis installation environment, clone the Vitis_Libraries repository, checkout a specific branch, and pull the latest changes.

```shell
source <Vitis_install_path>/Vitis/2023.2/settings64.sh
git clone https://github.com/Xilinx/Vitis_Libraries.git
cd motor_control/
git checkout next 
git pull
```

--------------------------------

### Setup Vitis Build Environment

Source: https://github.com/xilinx/vitis_libraries/blob/main/utils/README.md

Sets up the build environment for Vitis projects by sourcing the Vitis setup script and exporting the PLATFORM_REPO_PATHS environment variable. This allows makefiles to use the PLATFORM variable as a pattern, simplifying platform file path configuration. It requires the Vitis installation path to be correctly set.

```bash
source /opt/xilinx/2025.2/Vitis/settings64.sh
export PLATFORM_REPO_PATHS=/opt/xilinx/platforms
```

--------------------------------

### Setup Commands for Embedded Devices

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/L3/README.md

Commands to set up the environment for embedded devices, including sourcing Vitis, setting platform and sysroot paths. It also covers the process of downloading and preparing the platform and common-image for sysroot installation.

```bash
# Download the platform, and common-image from Xilinx Download Center.
# Run the sdk.sh script from the common-image directory to install sysroot using the command : "./sdk.sh -y -d ./ -p"
# Unzip the rootfs file : "gunzip ./rootfs.ext4.gz"
source < path-to-Vitis-installation-directory >/settings64.sh
export PLATFORM=< path-to-platform-directory >/< platform >.xpfm
export SYSROOT=< path-to-platform-sysroot >
make host xclbin TARGET=< hw_emu|hw > 
make run TARGET=< hw_emu|hw > #This command will generate only the sd_card folder in case of hardware build.
```

--------------------------------

### Navigate to GESVJ Benchmark Directory

Source: https://github.com/xilinx/vitis_libraries/blob/main/solver/L2/benchmarks/gesvj/README.md

This command navigates the user to the directory containing the GESVJ benchmark example. It is a prerequisite for building and running the kernel. No external dependencies are required for this step.

```bash
cd L2/benchmarks/gesvj
```

--------------------------------

### Run Anaconda3 Installer

Source: https://github.com/xilinx/vitis_libraries/blob/main/blas/docs/src/user_guide/L1/pyenvguide.rst

Executes the Anaconda3 installer script. The installer may require 'bzip' to be installed. Follow the on-screen prompts, including initializing Anaconda3 by running 'conda init'.

```bash
$ bash ./Anaconda3-2019.03-Linux-x86_64.sh
```

--------------------------------

### Download Anaconda3 Installer

Source: https://github.com/xilinx/vitis_libraries/blob/main/blas/docs/src/user_guide/L1/pyenvguide.rst

Downloads the Anaconda3 installer script. This script is used to install the Anaconda Python distribution, which provides a convenient way to manage Python packages and environments. Ensure you have 'wget' installed.

```bash
$ wget https://repo.anaconda.com/archive/Anaconda3-2019.03-Linux-x86_64.sh
```

--------------------------------

### Run L2 Example (x86sim/aiesim/hw_emu/hw)

Source: https://github.com/xilinx/vitis_libraries/blob/main/ultrasound/docs/src/tutorial/tutorial.rst

This bash script shows how to run L2 examples for modules like 'apodization' across different targets: x86 simulation, AIE simulation, hardware emulation (which includes PetaLinux launch), and full hardware build.

```bash
#!/bin/bash
   cd L2/tests/apodization # apodization is an example case. Please change directory to any other cases in L2/test if interested.
   make run TARGET=x86sim  # run the x86sim
   make run TARGET=aiesim  # run the aiesim
   make run TARGET=hw_emu  # run hw_emu. Build host and run hardware emulation, this step would lauch petalinux
   make all TARGET=hw      # build hw

```

--------------------------------

### Setup xf_blas Conda Environment

Source: https://github.com/xilinx/vitis_libraries/blob/main/blas/docs/src/user_guide/L1/pyenvguide.rst

Configures conda to use the 'anaconda' channel, creates a new conda environment from 'environment.yml', activates the 'xf_blas' environment, and installs packages listed in 'requirements.txt'. This should be run from the 'xf_blas/' directory.

```bash
$ conda config --add channels anaconda
$ conda env create -f environment.yml
$ conda activate xf_blas
$ conda install --file requirements.txt
```

--------------------------------

### Vitis Custom Convolution Example - Verification Results

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/tutorial.rst

This snippet shows the expected verification results after running the Vitis custom convolution example. It indicates the minimum and maximum intensity errors and the percentage of pixels above the error threshold, concluding with a 'Test Passed' message.

```text
INFO: Verification results:
        Minimum error in intensity = 0
        Maximum error in intensity = 1
        Percentage of pixels above error threshold = 0

	Test Passed .... !!!

```

--------------------------------

### FFT Window Scaling and Configuration Example (C++)

Source: https://github.com/xilinx/vitis_libraries/blob/main/dsp/docs/src/user_guide/L2/func-fft_window.rst

This C++ code example demonstrates the configuration and usage of the FFT window, specifically highlighting the TP_SHIFT parameter for scaling. It assumes integer data types and illustrates how TP_SHIFT normalizes output values to prevent saturation. Note that for cfloat data types, TP_SHIFT must be 0 to avoid errors.

```cpp
#include "fft_window.hpp"

int main() {
    // Example configuration for a 1024-point FFT window with TP_SHIFT = 14
    // For integer types, TP_SHIFT determines the scaling factor.
    // A TP_SHIFT of 14 normalizes output values for int16 to prevent saturation.
    xf::dsp::fft::details::FFTWindow<1024, ::hls::TlmTypes::cint16, 14> fft_window_int16;

    // Example configuration for a cfloat data type FFT window
    // For cfloat, TP_SHIFT must be 0, otherwise an error will occur.
    xf::dsp::fft::details::FFTWindow<1024, ::hls::TlmTypes::cfloat, 0> fft_window_cfloat;

    // ... rest of the example code ...

    return 0;
}
```

--------------------------------

### Set XCL_BINDIR Environment Variable for Vitis

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/getting-started-with-vitis-vision.rst

Sets the XCL_BINDIR environment variable to specify the directory containing Vitis xclbin files. This is crucial for the build and execution process. The example shows setting it to 'xclbin_zcu102_base_hw'.

```bash
export XCL_BINDIR=< xclbin-folder-present-in-the-sd_card > #For example, "export XCL_BINDIR=xclbin_zcu102_base_hw"
```

--------------------------------

### Clone Vitis Libraries Repository

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/tutorial.rst

This command clones the Vitis Libraries repository from GitHub into the specified working directory. Ensure you have Git installed and sufficient network bandwidth for the download. The cloned directory will contain various library categories, including 'vision'.

```c
cd /home/project
git clone https://github.com/Xilinx/Vitis_Libraries.git
```

--------------------------------

### Build GESVJ Kernel and Host Binary

Source: https://github.com/xilinx/vitis_libraries/blob/main/solver/L2/benchmarks/gesvj/README.md

This script builds the XCLBIN (kernel binary) and the host executable for the GESVJ kernel. It requires Vitis and XRT environment setups and a specified platform. The process can be time-consuming. Inputs include environment variables for Vitis, XRT, and the target platform. Outputs are the compiled kernel and host binaries.

```bash
source /opt/xilinx/Vitis/2022.2/settings64.sh
source /opt/xilinx/xrt/setenv.sh
export PLATFORM=/opt/xilinx/platforms/xilinx_u250_xdma_201830_2/xilinx_u250_xdma_201830_2.xpfm
export TARGET=hw
make run
```

--------------------------------

### Setup Vitis and XRT Environment

Source: https://github.com/xilinx/vitis_libraries/blob/main/ultrasound/L2/tests/README.md

Configures the necessary environment variables for Vitis and XRT, including installation paths, platform settings, and system root, root filesystem, and kernel image paths. This script is essential before running any Vitis compilation or execution commands.

```bash
#!/bin/bash
# setup vitis_24.2 env
source <Vitis_install_path>/Vitis/2024.2/settings64.sh
source /opt/xilinx/xrt/setup.sh
export PLATFORM_REPO_PATHS=<path to platforms>
export PLATFORM=xilinx_vck190_base_202420_1
# set up your SYSROOT, ROOTFS and K_IMAGE PATH
export SYSROOT=<path to platforms>/sw/versal/xilinx-versal-common-v2024.2/sysroots/aarch64-xilinx-linux/
export ROOTFS=<path to platforms>/sw/versal/xilinx-versal-common-v2024.2/rootfs.ext4
export K_IMAGE=<path to platforms>/sw/versal/xilinx-versal-common-v2024.2/Image
```

--------------------------------

### Run L1/L2 Example (x86sim/aiesim)

Source: https://github.com/xilinx/vitis_libraries/blob/main/ultrasound/docs/src/tutorial/tutorial.rst

This bash script demonstrates how to run L1 or L2 examples for the 'absV' module using either x86 simulation or AIE simulation targets. Users can change the directory to other cases within L1/tests or L2/tests.

```bash
#!/bin/bash
   cd L2/tests/absV        # absV is an example case. Please change directory to any other cases in L1/test if interested.
   make run TARGET=x86sim  # run the x86sim
   make run TARGET=aiesim  # run the aiesim

```

--------------------------------

### L2 APIs Input Arguments Example

Source: https://github.com/xilinx/vitis_libraries/blob/main/ultrasound/docs/src/tutorial/tutorial.rst

This describes the expected command-line arguments for L2 APIs, including the kernel (xclbin) name and the path to the input data. This is crucial for running host applications that interact with the accelerated modules.

```bash
   Usage: host.exe -[xclbin  data]
          -xclbin: the kernel name
          -data: the path to the input data

```

--------------------------------

### Create and Run Vitis HLS Custom Convolution Project (Shell Script)

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/tutorial.rst

This command initiates the creation and C simulation of a Vitis HLS project for the custom convolution example. The 'TARGET' variable can be modified to perform C-Synthesis, Co-Simulation, or Vivado Implementation. Successful execution concludes with a 'PASS' status.

```c
make run TARGET=CSIM
```

--------------------------------

### Configure Vitis Environment for L1 Functions (Shell Script)

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/tutorial.rst

This script configures the necessary environment variables for using Vitis L1 functions. It sources Vitis and XRT setup scripts, sets the platform, OpenCV paths, and LD_LIBRARY_PATH. Finally, it executes a make command to run the target application.

```c
source < path-to-Vitis-installation-directory >/settings64.sh
source < part-to-XRT-installation-directory >/setup.sh
export PLATFORM=< path-to-platform-directory >/< platform >.xpfm
export OPENCV_INCLUDE=< path-to-opencv-include-folder >
export OPENCV_LIB=< path-to-opencv-lib-folder >
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:< path-to-opencv-lib-folder >
make run TARGET=<CSIM / CSYNTH / COSIM / VIVADO_IMPL>
```

--------------------------------

### Navigate to Gaussian Difference Directory

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/gaussiandifference-bm.rst

Changes the current directory to the L3/examples/gaussiandifference folder. This is the first step before building or running the example.

```bash
cd L3/example/gaussiandifference
```

--------------------------------

### Vitis Custom Convolution L3 Application Example

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/tutorial.rst

This C++ code snippet demonstrates an L3 application within the Vitis Vision library. It showcases a pipeline of kernels, including color detection, erosion, and dilation, using dataflow for parallel execution. The function signature includes input/output image pointers and control parameters.

```c++
void color_detect(ap_uint<PTR_IN_WIDTH>* img_in,
        unsigned char* low_thresh,
        unsigned char* high_thresh,
        unsigned char* process_shape,
        ap_uint<PTR_OUT_WIDTH>* img_out,
        int rows,
        int cols) {

   #pragma HLS INTERFACE m_axi      port=img_in        offset=slave  bundle=gmem0
   #pragma HLS INTERFACE m_axi      port=low_thresh    offset=slave  bundle=gmem1
   #pragma HLS INTERFACE s_axilite  port=low_thresh 
   #pragma HLS INTERFACE m_axi      port=high_thresh   offset=slave  bundle=gmem2
   #pragma HLS INTERFACE s_axilite  port=high_thresh 
   #pragma HLS INTERFACE s_axilite  port=rows 
   #pragma HLS INTERFACE s_axilite  port=cols 
   #pragma HLS INTERFACE m_axi      port=process_shape offset=slave  bundle=gmem3
   #pragma HLS INTERFACE s_axilite  port=process_shape
   #pragma HLS INTERFACE m_axi      port=img_out       offset=slave  bundle=gmem4
   #pragma HLS INTERFACE s_axilite  port=return

   xf::cv::Mat<IN_TYPE, HEIGHT, WIDTH, NPC1, XF_CV_DEPTH_IN_1> imgInput(rows, cols);
   xf::cv::Mat<IN_TYPE, HEIGHT, WIDTH, NPC1, XF_CV_DEPTH_RGB2HSV> rgb2hsv(rows, cols);
   xf::cv::Mat<OUT_TYPE, HEIGHT, WIDTH, NPC1, XF_CV_DEPTH_HELP_1> imgHelper1(rows, cols);
   xf::cv::Mat<OUT_TYPE, HEIGHT, WIDTH, NPC1, XF_CV_DEPTH_HELP_2> imgHelper2(rows, cols);
   xf::cv::Mat<OUT_TYPE, HEIGHT, WIDTH, NPC1, XF_CV_DEPTH_HELP_3> imgHelper3(rows, cols);
   xf::cv::Mat<OUT_TYPE, HEIGHT, WIDTH, NPC1, XF_CV_DEPTH_HELP_4> imgHelper4(rows, cols);
   xf::cv::Mat<OUT_TYPE, HEIGHT, WIDTH, NPC1, XF_CV_DEPTH_OUT_1> imgOutput(rows, cols);

   // Copy the shape data:
   unsigned char _kernel[FILTER_SIZE * FILTER_SIZE];
   for (unsigned int i = 0; i < FILTER_SIZE * FILTER_SIZE; ++i) {
    #pragma HLS PIPELINE
    _kernel[i] = process_shape[i];
   }

   #pragma HLS DATAFLOW

   // Retrieve xf::cv::Mat objects from img_in data:
   xf::cv::Array2xfMat<PTR_IN_WIDTH, IN_TYPE, HEIGHT, WIDTH, NPC1>(img_in, imgInput);

   // Convert RGBA to HSV:
   xf::cv::bgr2hsv<IN_TYPE, HEIGHT, WIDTH, NPC1>(imgInput, rgb2hsv);

   // Do the color thresholding:
   xf::cv::colorthresholding<IN_TYPE, OUT_TYPE, MAXCOLORS, HEIGHT, WIDTH, NPC1>(rgb2hsv, imgHelper1, low_thresh,
                       high_thresh);

   // Use erode and dilate to fully mark color areas:
   xf::cv::erode<XF_BORDER_CONSTANT, OUT_TYPE, HEIGHT, WIDTH, XF_KERNEL_SHAPE, FILTER_SIZE, FILTER_SIZE, ITERATIONS,
        NPC1>(imgHelper1, imgHelper2, _kernel);
   xf::cv::dilate<XF_BORDER_CONSTANT, OUT_TYPE, HEIGHT, WIDTH, XF_KERNEL_SHAPE, FILTER_SIZE, FILTER_SIZE, ITERATIONS,
         NPC1>(imgHelper2, imgHelper3, _kernel);
}

```

--------------------------------

### Set Up Environment and Build Vitis HLS Project (Command Line)

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/getting-started-with-hls.rst

This snippet shows the necessary commands to set up the environment variables for Vitis and XRT, define the target platform and OpenCV paths, and then execute the build process for a Vitis HLS project using a Makefile. It supports different build targets like C simulation, C synthesis, and co-simulation.

```c
source < path-to-Vitis-installation-directory >/settings64.sh

source < part-to-XRT-installation-directory >/setup.sh

export PLATFORM=< path-to-platform-directory >/< platform >.xpfm

export OPENCV_INCLUDE=< path-to-opencv-include-folder >

export OPENCV_LIB=< path-to-opencv-lib-folder >

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:< path-to-opencv-lib-folder >

make run TARGET=< csim / csynth / cosim/ vivado-impl >
```

--------------------------------

### Run GESVJ Kernel and Get Benchmark Results

Source: https://github.com/xilinx/vitis_libraries/blob/main/solver/L2/benchmarks/gesvj/README.md

This command executes the compiled GESVJ kernel and its associated host application to obtain benchmark results. It requires the path to the generated XCLBIN file and specifies parameters like the number of runs, matrix dimensions, and a random seed. The output includes execution times and other performance metrics.

```bash
./build_dir.hw.xilinx_u250_xdma_201830_2/test_gesvj.exe -xclbin build_dir.hw.xilinx_u250_xdma_201830_2/kernel_gesvj.xclbin -runs 1 -M 512 -N 512 -seed 12
```

--------------------------------

### AXIvideo2cvMatxf

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/getting-started-with-hls.rst

Converts an AXI4 streaming video input to a cv::Mat image representation.

```APIDOC
## AXIvideo2cvMatxf

### Description
Converts an image as AXI4 streaming video to a cv::Mat representation.

### Method
This is a template function, typically used within a larger hardware acceleration context.

### Endpoint
N/A (Function signature)

### Parameters
#### Template Parameters
- **NPC** (int) - Number of pixels to be processed per cycle. Possible options are XF_NPPC1 and XF_NPPC8 for 1-pixel and 8-pixel operations respectively.
- **W** (int) - Data width of AXI4-Stream. Recommended value is pixel depth.

#### Function Parameters
- **AXI_video_strm** (hls::stream<ap_axiu<W,1,1,1> >&) - HLS stream of ap_axiu (axi protocol) type.
- **cv_mat** (cv::Mat&) - Output image.

### Request Example
```c
template<int NPC,int W>
void AXIvideo2cvMatxf(hls::stream<ap_axiu<W,1,1,1> >& AXI_video_strm, cv::Mat& cv_mat)
```

### Response
#### Success Response (void)
This function does not return a value, but modifies the cv_mat.

#### Response Example
N/A
```

--------------------------------

### Launch Kernel and Profile Execution using OpenCL

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/include/isp_aio_adas_api.rst

This snippet shows how to launch an OpenCL kernel on the FPGA and measure its execution time. It includes enqueuing the task, waiting for completion, and retrieving profiling information (start and end times). Ensure the kernel and command queue are properly set up.

```cpp
// Profiling Objects
        cl_ulong start = 0;
        cl_ulong end = 0;
        double diff_prof = 0.0f;
        cl::Event event_sp;

        // Launch the kernel

        OCL_CHECK(err, err = q.enqueueTask(kernel, NULL, &event_sp));

        clWaitForEvents(1, (const cl_event*)&event_sp);

        event_sp.getProfilingInfo(CL_PROFILING_COMMAND_START, &start);

        event_sp.getProfilingInfo(CL_PROFILING_COMMAND_END, &end);

        diff_prof = end - start;
        std::cout << (diff_prof / 1000000) << "ms" << std::endl;
```

--------------------------------

### cvMat2AXIvideoxf

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/getting-started-with-hls.rst

Converts an image represented as cv::Mat to an AXI4 streaming video output.

```APIDOC
## cvMat2AXIvideoxf

### Description
Converts an image represented as cv::Mat to an AXI4 streaming video output.

### Method
This is a template function, typically used within a larger hardware acceleration context.

### Endpoint
N/A (Function signature)

### Parameters
#### Template Parameters
- **NPC** (int) - Number of pixels to be processed per cycle. Possible options are XF_NPPC1 and XF_NPPC8 for 1-pixel and 8-pixel operations respectively.
- **W** (int) - Data width of AXI4-Stream. Recommended value is pixel depth.

#### Function Parameters
- **cv_mat** (cv::Mat&) - Input image.
- **AXI_video_strm** (hls::stream<ap_axiu<W,1,1,1> >&) - HLS stream of ap_axiu (axi protocol) type.

### Request Example
```c
template<int NPC,int W>
void cvMat2AXIvideoxf(cv::Mat& cv_mat, hls::stream<ap_axiu<W,1,1,1> >& AXI_video_strm)
```

### Response
#### Success Response (void)
This function does not return a value, but modifies the AXI_video_strm.

#### Response Example
N/A
```

--------------------------------

### xfblasExecute

Source: https://github.com/xilinx/vitis_libraries/blob/main/blas/docs/src/user_guide/L3/L3_overview_content.rst

Starts the kernel and waits for its completion.

```APIDOC
## xfblasExecute

### Description
This function starts the kernel and waits until it finishes.

### Method
`xfblasExecute (unsigned int kernelIndex = 0, unsigned int deviceIndex = 0)`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **kernelIndex** (unsigned int, optional) - Index of the kernel that is being used; default is 0.
- **deviceIndex** (unsigned int, optional) - Index of the device that is being used; default is 0.

### Request Example
```cpp
// Execute kernel with default indices
xfblasExecute();

// Execute kernel with specific indices
xfblasExecute(1, 0);
```

### Response
#### Success Response (0)
- **xfblasStatus_t** (int) - 0 if the operation completed successfully.

#### Error Responses
- **xfblasStatus_t** (int) - 1 if the library was not initialized.
- **xfblasStatus_t** (int) - 3 if there is no FPGA device memory allocated for instruction.

#### Response Example
```json
{
  "status": 0
}
```
```

--------------------------------

### Example Output of Kalman Filter Benchmark

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/kalmanfilter-bm.rst

Illustrates the expected output when running the Kalman Filter benchmark. Includes initialization information, verification details, OpenCL setup, and the final test pass status.

```bash
-----------Kalman Design---------------
INFO: Init cv::Mat objects.
INFO: Kalman Filter Verification:
	Number of state variables: 16
	Number of measurements: 16
	Number of control input: 16
INFO: Running OpenCL section.
Found Platform
Platform Name: Xilinx
INFO: Device found - xilinx_u200_xdma_201830_2
XCLBIN File Name: krnl_kalmanfilter
INFO: Importing Vitis_Libraries/vision/L2/examples/kalmanfilter/Xilinx_Kalmanfilter_L2_Test_vitis_hw_u200/build_dir.hw.xilinx_u200_xdma_201830_2/krnl_kalmanfilter.xclbin
Loading: 'Vitis_Libraries/vision/L2/examples/kalmanfilter/Xilinx_Kalmanfilter_L2_Test_vitis_hw_u200/build_dir.hw.xilinx_u200_xdma_201830_2/krnl_kalmanfilter.xclbin'
INFO: Test Pass
------------------------------------------------------------
```

--------------------------------

### Navigate to ISP Pipeline Example Directory

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/ISPpipeline-bm.rst

Changes the current directory to the ISP Pipeline example location within the Vitis libraries. This is the first step before building or running the example.

```bash
cd L3/examples/isppipeline
```

--------------------------------

### Setup Commands for PCIe Devices

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/L3/README.md

These commands set up the necessary environment variables for building and running Vitis applications on PCIe devices. It includes sourcing Vitis and XRT, setting the platform, OpenCV paths, and making the host and xclbin for hardware or hardware emulation.

```bash
source < path-to-Vitis-installation-directory >/settings64.sh
source < path-to-XRT-installation-directory >/setup.sh
export PLATFORM=< path-to-platform-directory >/< platform >.xpfm
export OPENCV_INCLUDE=< path-to-opencv-include-folder >
export OPENCV_LIB=< path-to-opencv-lib-folder >
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:< path-to-opencv-lib-folder >
make host xclbin TARGET=< hw_emu|hw >
make run TARGET=< hw_emu|hw >
```

--------------------------------

### Build and Run Commands for Embedded Devices (Shell Script)

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/getting-started-with-vitis-vision.rst

Details shell commands for building and running Vitis kernels on embedded devices, including hardware emulation and hardware builds. Requires platform and sysroot setup, along with Vitis environment configuration. Commands utilize `make` for host and bitstream generation, and `make run` for execution, noting the generation of an `sd_card` folder for hardware runs.

```shell
#Download the platform, and common-image from Xilinx Download Center. Run the sdk.sh script from the common-image directory to install sysroot using the command: 
$ ./sdk.sh -y -d ./ -p

#Unzip the rootfs file
"gunzip ./rootfs.ext4.gz"

source < path-to-Vitis-installation-directory >/settings64.sh
export PLATFORM=< path-to-platform-directory >/< platform >.xpfm
export SYSROOT=< path-to-platform-sysroot >
make host xclbin TARGET=< hw_emu|hw > 
make run TARGET=< hw_emu|hw > #This command will generate only the sd_card folder in case of hardware build.
```

--------------------------------

### Navigate to FAST Example Directory

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/fast-bm.rst

Changes the current directory to the FAST example's location within the L2 examples folder. This is the first step before building or running the example.

```bash
cd L2/examples/fast
```

--------------------------------

### Setup Environment for Vitis and XRT

Source: https://github.com/xilinx/vitis_libraries/blob/main/blas/README.md

This snippet shows how to set up the necessary environment variables for using Vitis and XRT. It involves sourcing the respective setup scripts, which is crucial before compiling or running any Vitis-related applications. Ensure the paths to Vitis and XRT are correct for your installation.

```shell
source <install path>/2025.2/Vitis/settings64.sh
source /opt/xilinx/xrt/setup.sh
```

--------------------------------

### Example Output of Gaussian Difference

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/gaussiandifference-bm.rst

Demonstrates the expected output when running the Gaussian Difference example. It includes information about platform detection, device found, XCLBIN loading, and test results.

```bash
-----------Guassian Difference Design---------------
INFO: Running OpenCL section.
Found Platform
Platform Name: Xilinx
INFO: Device found - xilinx_u200_xdma_201830_2
XCLBIN File Name: krnl_gaussiandifference
INFO: Importing Vitis_Libraries/vision/L3/examples/gaussiandifference/Xilinx_Gaussiandifference_L3_Test_vitis_hw_u200/build_dir.hw.xilinx_u200_xdma_201830_2/krnl_gaussiandifference.xclbin
Loading: 'Vitis_Libraries/vision/L3/examples/gaussiandifference/Xilinx_Gaussiandifference_L3_Test_vitis_hw_u200/build_dir.hw.xilinx_u200_xdma_201830_2/krnl_gaussiandifference.xclbin'
Test Passed 
------------------------------------------------------------
```

--------------------------------

### xfMat2Array API

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/getting-started-with-vitis-vision.rst

Converts an xf::cv::Mat object to a memory pointer. This function supports line stride.

```APIDOC
## xfMat2Array Function Overloads

### Description
These functions convert an input `xf::cv::Mat` object to a pointer to an array of `ap_uint<PTR_WIDTH>`.

### Method
- `xfMat2Array` (template function)

### Endpoint
N/A (This is a library function, not a network endpoint)

### Parameters
#### Template Parameters
- **PTR_WIDTH** (int) - Data width of the output pointer. Must be a power of 2, from 8 to 512.
- **MAT_T** (int) - Input Mat type. Examples: `XF_8UC1`, `XF_16UC1`, `XF_8UC3`, `XF_8UC4`.
- **ROWS** (int) - Maximum height of the image.
- **COLS** (int) - Maximum width of the image.
- **NPC** (int) - Number of pixels computed in parallel. Examples: `XF_NPPC1`, `XF_NPPC8`.
- **XFCVDEPTH** (int, optional) - Depth of the input image. Defaults to `_XFCVDEPTH_DEFAULT`.
- **FILLZERO** (int, optional) - Line padding flag. Use when line stride support is needed. Defaults to 1.

#### Input Arguments
- **srcMat** (xf::cv::Mat<MAT_T,ROWS,COLS,NPC,XFCVDEPTH>&) - Input image of type `xf::cv::Mat`.
- **dstPtr** (ap_uint<PTR_WIDTH > *) - Output pointer. The type of the pointer is based on `PTR_WIDTH`.
- **stride** (int, optional) - Line stride. Defaults to `srcMat.cols`.

### Request Example
(This is a C++ function, not a request/response API)

### Response
N/A (This function operates in-memory)

### Error Handling
- **PTR_WIDTH** must be a power of 2 between 8 and 512.
- Refer to the "Interface Pointer Widths" table for minimum and maximum `PTR_WIDTH` requirements based on `MAT_T` and `NPC`.
```

--------------------------------

### Setup Vitis and XRT Environment using Shell Scripts

Source: https://github.com/xilinx/vitis_libraries/blob/main/blas/L3/benchmarks/README.md

These commands set up the necessary environment variables for Vitis and Xilinx Runtime (XRT). This is a crucial step before building or running Vitis kernels and applications. Replace '<install path>' with your actual Vitis installation directory.

```shell
source <install path>/2025.1/Vitis/settings64.sh
source /opt/xilinx/xrt/setup.sh
```

--------------------------------

### Navigate to StereoLBM Example Directory - Bash

Source: https://github.com/xilinx/vitis_libraries/blob/main/vision/docs/src/stereolbm-bm.rst

This command changes the current directory to the location of the Stereo Local Block Matching example within the Vitis libraries. This is typically the first step before building or running the example.

```bash
cd L2/examples/stereolbm
```

--------------------------------

### Navigate to RC4 Benchmark Directory

Source: https://github.com/xilinx/vitis_libraries/blob/main/security/docs/src/guide_L1/benchmark/rc4.rst

This command changes the current directory to the root of the RC4 benchmark for subsequent operations. It assumes Vitis library setup is complete.

```bash
cd L1/benchmarks/rc4
```

--------------------------------

### Setup Vitis and PetaLinux Environment

Source: https://github.com/xilinx/vitis_libraries/blob/main/ultrasound/docs/src/tutorial/tutorial.rst

This bash script sets up the necessary environment variables for Vitis and XRT, including defining platform repository paths and PetaLinux-related configurations such as sysroot, rootfs, and kernel image.

```bash
#!/bin/bash

   # setup vitis env
   source <Vitis_install_path>/Vitis/2024.2/settings64.sh 
   source <XRT_install_path>/2024.2/xbb/xrt/packages/setenv.sh
   export PLATFORM_REPO_PATHS=<path_to_platforms>

   # set petalinux related env
   export SYSROOT=<path_to_platforms>/sw/versal/xilinx-versal-common-2024.2/sysroots/aarch64-xilinx-linux/ 
   export ROOTFS=<path_to_platforms>/sw/versal/xilinx-versal-common-2024.2/rootfs.ext4 
   export K_IMAGE=<path_to_platforms>/sw/versal/xilinx-versal-common-2024.2/Image

```
Tokens:
Raw