diff --git a/.github/workflows/develop-MSVC.yml b/.github/workflows/develop-MSVC.yml
index d092bc05..dfc2b87a 100644
--- a/.github/workflows/develop-MSVC.yml
+++ b/.github/workflows/develop-MSVC.yml
@@ -20,148 +20,94 @@ jobs:
         with:
          python-version: "3.11.4"
 
-      - name: Install Conan and PyYAML via pip
-        run: |
-         python -m pip install conan
-         python -m pip install PyYAML
-
-      - name: Disable Perl (remove from PATH)
-        run: choco uninstall strawberryperl -n
-
-      - name: Install WiX Toolset
-        run: choco install wixtoolset -y
-
-      - name: Checkout repository
-        uses: actions/checkout@v4.1.1
-        with:
-          submodules: recursive
-
       - name: Create and enter the build directory
         run: |
           cd installer
           mkdir build
           cd build
-
-      - name: Run CMake
-        working-directory: installer/build
-        run: cmake -G "Visual Studio 17 2022" -A x64 ../
-
-      - name: Build with CMake
-        working-directory: installer/build
-        run: cmake --build . --config Release
-
-      - name: Generate liscence files
-        working-directory: installer/build
-        run: cmake -G "Visual Studio 17 2022" -A x64 ../ 
-
-      - name: Package with CPack WIX
-        working-directory: installer/build
-        run: cpack -G "WIX"
-
-      - name: Upload artifacts MSI
-        uses: actions/upload-artifact@v4
-        with:
-          name: sensing-dev-installer-msi
-          path: |
-            installer/build/*.msi
-
-      - name: Create package zip
-        working-directory: installer/build
-        run: cpack -G "ZIP"
-
-      # - name: Create package without opencv
-      #   working-directory: installer/build
-      #   run:  cmake -G "Visual Studio 17 2022" -A x64 ../ -DOPENCV_ACTION="use_existing"
-
-      # - name: Create package msi
-      #   working-directory: installer/build
-      #   run: cpack -G "WIX"
-
-      # - name: Create package zip
-      #   working-directory: installer/build
-      #   run: cpack -G "ZIP"
+          python ${GITHUB_WORKSPACE}/installer/src/generate_config.py
       
       - name: Upload a Build Artifact
         uses: actions/upload-artifact@v4
         with:
           name: sensing-dev-installer-zip
           path: |
-            installer/build/*.zip
-  test:
-    runs-on: ${{ matrix.os }}
-    permissions:
-      id-token: write
-    strategy:
-        matrix:
-          os: [windows-2019, windows-2022]
-    needs: build
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4.1.1
-        with:
-          submodules: recursive
-
-      - name: Download All Artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: sensing-dev-installer-zip
-          merge-multiple: true
+            ${GITHUB_WORKSPACE}/build/config_Windows.json
+  # test:
+  #   runs-on: ${{ matrix.os }}
+  #   permissions:
+  #     id-token: write
+  #   strategy:
+  #       matrix:
+  #         os: [windows-2019, windows-2022]
+  #   needs: build
+  #   steps:
+  #     - name: Checkout repository
+  #       uses: actions/checkout@v4.1.1
+  #       with:
+  #         submodules: recursive
+
+  #     - name: Download All Artifacts
+  #       uses: actions/download-artifact@v4
+  #       with:
+  #         name: sensing-dev-installer-zip
+  #         merge-multiple: true
         
-      - name: Unzip
-        run: | 
-          mkdir ${HOME}/sensing-dev
-          unzip sensing-dev*.zip
-          mv sensing-dev*/* ${HOME}/sensing-dev
-          ls ${HOME}/sensing-dev
-
-      - name: Test arvis
-        run: |
-          $BINPATH="${HOME}/sensing-dev/bin"
-          $env:PATH="$env:PATH;$BINPATH"
-          $env:SENSING_DEV_ROOT="${HOME}/sensing-dev"
-          cd installer/testcases/cpp/aravis_test  && cmake ./
-          cmake --build . --config Release 
-          cd Release && ./aravis_test
-          echo "aravis test passed"
+  #     - name: Unzip
+  #       run: | 
+  #         mkdir ${HOME}/sensing-dev
+  #         unzip sensing-dev*.zip
+  #         mv sensing-dev*/* ${HOME}/sensing-dev
+  #         ls ${HOME}/sensing-dev
+
+  #     - name: Test arvis
+  #       run: |
+  #         $BINPATH="${HOME}/sensing-dev/bin"
+  #         $env:PATH="$env:PATH;$BINPATH"
+  #         $env:SENSING_DEV_ROOT="${HOME}/sensing-dev"
+  #         cd installer/testcases/cpp/aravis_test  && cmake ./
+  #         cmake --build . --config Release 
+  #         cd Release && ./aravis_test
+  #         echo "aravis test passed"
   
-      - name: Test ion-kit
-        run: |
-          $BINPATH="${HOME}/sensing-dev/bin"
-          $env:PATH="$env:PATH;$BINPATH"
-          $env:SENSING_DEV_ROOT="${HOME}/sensing-dev"
-          cd installer/testcases/cpp/ionkit_test && cmake ./
-          cmake --build . --config Release 
-          cd Release && ./ionkit_test
-          echo "ion-kit test passed"
+  #     - name: Test ion-kit
+  #       run: |
+  #         $BINPATH="${HOME}/sensing-dev/bin"
+  #         $env:PATH="$env:PATH;$BINPATH"
+  #         $env:SENSING_DEV_ROOT="${HOME}/sensing-dev"
+  #         cd installer/testcases/cpp/ionkit_test && cmake ./
+  #         cmake --build . --config Release 
+  #         cd Release && ./ionkit_test
+  #         echo "ion-kit test passed"
   
-      - name: Test opencv for MSVC 2019
-        if: matrix.os == 'windows-2019'
-        run: |
-          $BINPATH="${HOME}/sensing-dev/bin"
-          $OPENCVBIN="${HOME}/sensing-dev/opencv/build/x64/vc15/bin"
-          $env:PATH="$env:PATH;$BINPATH"
-          $env:PATH="$env:PATH;$OPENCVBIN"
-          $env:SENSING_DEV_ROOT="${HOME}/sensing-dev"
-          cd installer/testcases/cpp/opencv_test  && cmake ./
-          cmake --build . --config Release 
-          cd Release && ./opencv_test
-
-      - name: Install OpenCV separately on Windows MSVC 2022
-        if: matrix.os == 'windows-2022'
-        run: | 
-          Remove-Item -LiteralPath "${HOME}/sensing-dev/opencv" -Force -Recurse
-          $targetDir= "${HOME}/sensing-dev"
-          Invoke-WebRequest -Uri https://github.com/opencv/opencv/releases/download/4.10.0/opencv-4.10.0-windows.exe -OutFile opencv-4.10.0-windows.exe 
-          Start-Process -FilePath opencv-4.10.0-windows.exe -ArgumentList "-o`"$targetDir`" -y" -Wait
-
-      - name: Test opencv for MSVC 2022
-        if: matrix.os == 'windows-2022'
-        run: |
-          $BINPATH="${HOME}/sensing-dev/bin"
-          $OPENCVBIN="${HOME}/sensing-dev/opencv/build/x64/vc16/bin"
-          $env:PATH="$env:PATH;$BINPATH"
-          $env:PATH="$env:PATH;$OPENCVBIN"
-          $env:SENSING_DEV_ROOT="${HOME}/sensing-dev"
-          cd installer/testcases/cpp/opencv_test  && cmake ./
-          cmake --build . --config Release 
-          cd Release && ./opencv_test
+  #     - name: Test opencv for MSVC 2019
+  #       if: matrix.os == 'windows-2019'
+  #       run: |
+  #         $BINPATH="${HOME}/sensing-dev/bin"
+  #         $OPENCVBIN="${HOME}/sensing-dev/opencv/build/x64/vc15/bin"
+  #         $env:PATH="$env:PATH;$BINPATH"
+  #         $env:PATH="$env:PATH;$OPENCVBIN"
+  #         $env:SENSING_DEV_ROOT="${HOME}/sensing-dev"
+  #         cd installer/testcases/cpp/opencv_test  && cmake ./
+  #         cmake --build . --config Release 
+  #         cd Release && ./opencv_test
+
+  #     - name: Install OpenCV separately on Windows MSVC 2022
+  #       if: matrix.os == 'windows-2022'
+  #       run: | 
+  #         Remove-Item -LiteralPath "${HOME}/sensing-dev/opencv" -Force -Recurse
+  #         $targetDir= "${HOME}/sensing-dev"
+  #         Invoke-WebRequest -Uri https://github.com/opencv/opencv/releases/download/4.10.0/opencv-4.10.0-windows.exe -OutFile opencv-4.10.0-windows.exe 
+  #         Start-Process -FilePath opencv-4.10.0-windows.exe -ArgumentList "-o`"$targetDir`" -y" -Wait
+
+  #     - name: Test opencv for MSVC 2022
+  #       if: matrix.os == 'windows-2022'
+  #       run: |
+  #         $BINPATH="${HOME}/sensing-dev/bin"
+  #         $OPENCVBIN="${HOME}/sensing-dev/opencv/build/x64/vc16/bin"
+  #         $env:PATH="$env:PATH;$BINPATH"
+  #         $env:PATH="$env:PATH;$OPENCVBIN"
+  #         $env:SENSING_DEV_ROOT="${HOME}/sensing-dev"
+  #         cd installer/testcases/cpp/opencv_test  && cmake ./
+  #         cmake --build . --config Release 
+  #         cd Release && ./opencv_test
diff --git a/installer/CMakeLists.txt b/installer/CMakeLists.txt
deleted file mode 100644
index 5fbd64c7..00000000
--- a/installer/CMakeLists.txt
+++ /dev/null
@@ -1,83 +0,0 @@
-cmake_minimum_required(VERSION 3.15)
-project(sensing-dev CXX)
-set(CMAKE_CXX_STANDARD 17)
-
-message(STATUS "Building with CMake version: ${CMAKE_VERSION}")
-
-# Load the CMake ExternalProject module
-include(ExternalProject)
-add_subdirectory(external)
-
-# Add your main executable
-add_executable(${PROJECT_NAME} src/installer.cpp)
-
-# Link against aravis, pygobject, ion-kit, and OpenCV libraries
-# target_link_libraries(${PROJECT_NAME} aravis::aravis)
-
-
-#version
-# set(SENSING_DEV_INSTALLER_VERSION_MAJOR 23)
-# set(SENSING_DEV_INSTALLER_VERSION_MINOR 08)
-# set(SENSING_DEV_INSTALLER_VERSION_PATCH 00)
-
-execute_process(
-    COMMAND git describe --abbrev=0 --tags
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_LATEST_TAG
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-if(NOT GIT_LATEST_TAG)
-    message(WARNING "No git tags found. Setting version to default.")
-
-    string(TIMESTAMP CURRENT_YEAR "%Y")
-    math(EXPR CURRENT_YEAR_SHORT "${CURRENT_YEAR} - 2000")
-    string(TIMESTAMP CURRENT_MONTH "%m")
-    string(TIMESTAMP CURRENT_DAY "%d")
-
-    set(GIT_LATEST_TAG "v${CURRENT_YEAR_SHORT}.${CURRENT_MONTH}.${CURRENT_DAY}")
-endif()
-
-if(GIT_LATEST_TAG MATCHES "^v([0-9]+)\\.([0-9]+)\\.([0-9]+)-?(.*)$")
-    set(SENSING_DEV_INSTALLER_VERSION_MAJOR "${CMAKE_MATCH_1}")
-    set(SENSING_DEV_INSTALLER_VERSION_MINOR "${CMAKE_MATCH_2}")
-    set(SENSING_DEV_INSTALLER_VERSION_PATCH "${CMAKE_MATCH_3}")
-    set(SENSING_DEV_INSTALLER_VERSION_TAG "${CMAKE_MATCH_4}")
-else()
-    message(FATAL_ERROR "Failed to parse version from tag '${GIT_LATEST_TAG}'")
-endif()
-
-
-configure_file(
-    ${CMAKE_CURRENT_SOURCE_DIR}/Version.h.in
-    ${CMAKE_CURRENT_BINARY_DIR}/Version.h
-)
-
-set(SENSING_DEV_INSTALLER_VCSVERSION "${SENSING_DEV_INSTALLER_VERSION_MAJOR}.${SENSING_DEV_INSTALLER_VERSION_MINOR}.${SENSING_DEV_INSTALLER_VERSION_PATCH}")
-
-message(STATUS "Sensing Dev Installer Version : ${SENSING_DEV_INSTALLER_VCSVERSION}")
-
-
-# # Install sensing-dev-installer
-install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)
-
-# Include header files
-install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/ DESTINATION include  FILES_MATCHING PATTERN "*.h;*.hpp" )
-install(FILES ${CMAKE_BINARY_DIR}/Version.h DESTINATION include)
-install(DIRECTORY ${CMAKE_SOURCE_DIR}/tools/ DESTINATION tools)
-install(FILES ${CMAKE_SOURCE_DIR}/license/LICENSE DESTINATION license)
-
-# For MSVC generator
-if(MSVC)    
-    install(FILES ${CMAKE_BINARY_DIR}/license/thirdparty_notice.txt DESTINATION license)
-    set(THIRPARTY_NOTICE_FILE_RTF "${CMAKE_BINARY_DIR}/license/thirdparty_notice.rtf")
-
-    # Copy and concatenate license files
-    file(READ  ${CMAKE_BINARY_DIR}/license/thirdparty_notice.txt content)
-    file(WRITE ${THIRPARTY_NOTICE_FILE_RTF} "${content}\n--------\n")
-    install(DIRECTORY ${CMAKE_BINARY_DIR}/license/ DESTINATION license)    
-endif()
-
-# install(CODE "execute_process(COMMAND powershell -ExecutionPolicy Bypass -File \${CMAKE_INSTALL_PREFIX}/tools/Env.ps1 -installPath \${CMAKE_INSTALL_PREFIX})")
-
-
-include(cmake/CPackConfig.cmake)
diff --git a/installer/cmake/CPackConfig.cmake b/installer/cmake/CPackConfig.cmake
deleted file mode 100644
index 1577079a..00000000
--- a/installer/cmake/CPackConfig.cmake
+++ /dev/null
@@ -1,63 +0,0 @@
-# Check for CPack availability
-if(NOT EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
-  message(STATUS "CPack is not found. Skipping CPack configuration.")
-  return()
-endif()
-
-# set(CPACK_GENERATOR "NSIS;WIX")  # NSIS and WiX generators for MSI
-set(CPACK_GENERATOR "WIX") # NSIS and WiX generators for MSI
-
-# Set common CPack variables
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Sensing dev installer")
-set(CPACK_PACKAGE_VENDOR "Fixstars Solution Inc")
-set(CPACK_PACKAGE_VERSION "${SENSING_DEV_INSTALLER_VCSVERSION}")
-set(CPACK_PACKAGE_VERSION_MAJOR "${SENSING_DEV_INSTALLER_VERSION_MAJOR}")
-set(CPACK_PACKAGE_VERSION_MINOR "${SENSING_DEV_INSTALLER_VERSION_MINOR}")
-set(CPACK_PACKAGE_VERSION_PATCH "${SENSING_DEV_INSTALLER_VERSION_PATCH}")
-set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/license/thirdparty_notice.rtf")
-set(CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}/resources/sensing_dev_logo.ico")
-# set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_SYSTEM_NAME}")
-
-set(CPACK_OPENCV_COMPONENT "")
-if(OPENCV_ACTION STREQUAL "use_existing")
-  set(CPACK_OPENCV_COMPONENT "-no-opencv")
-endif()
-
-set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}${CPACK_OPENCV_COMPONENT}-${SENSING_DEV_INSTALLER_VCSVERSION}-win64")
-
-# # set(CPACK_SET_DESTDIR "ON")
-# message(STATUS "CPack Generator: ${CPACK_GENERATOR}")
-
-# # set(CPACK_WIX_ROOT_FOLDER_ID "LocalAppDataFolder")
-
-# # Define the path to your PowerShell script relative to the source directory
-# set(PS_SCRIPT_PATH "${CMAKE_SOURCE_DIR}/tools/Env.ps1")
-# set(INSTALLATION_DIR "$env:{CMAKE_INSTALL_PREFIX}")
-
-# # Configure the CMake script to invoke the PowerShell script
-# configure_file("${CMAKE_SOURCE_DIR}/cmake/PostInstallScript.cmake.in"
-#   "${CMAKE_BINARY_DIR}/PostInstallScript.cmake"
-#   @ONLY)
-
-# # Set the CPACK_INSTALL_SCRIPTS variable to the generated script
-# set(CPACK_INSTALL_SCRIPTS "${CMAKE_BINARY_DIR}/PostInstallScript.cmake")
-
-# Generator-specific settings
-if(CPACK_GENERATOR STREQUAL "WIX")
-  # CPack settings for the WIX generator
-  set(CPACK_WIX_UPGRADE_GUID D2E80558-5056-4993-899C-AC81AA7D6286)
-  set(CPACK_WIX_PRODUCT_GUID BEC319CD-78B2-4B68-8978-70D84B9497EB)
-
-# set(CPACK_WIX_UI_REF "WixUI_Mondo")
-# set(CPACK_WIX_LICENSE_RTF ${THIRPARTY_NOTICE_FILE_RTF})
-elseif(CPACK_GENERATOR STREQUAL "NSIS")
-  # CPack settings for the NSIS generator
-  # Uncomment and adjust settings as needed for NSIS
-  # set(CPACK_GENERATOR "NSIS")
-  # set(CPACK_NSIS_MODIFY_PATH TRUE)
-  # set(CPACK_NSIS_INSTALL_ROOT "${CPACK_PACKAGING_INSTALL_PREFIX}")
-  # ...
-endif()
-
-# Include CPack
-include(CPack)
diff --git a/installer/cmake/InstallerNSISInclude.nsh b/installer/cmake/InstallerNSISInclude.nsh
deleted file mode 100644
index 1300384a..00000000
--- a/installer/cmake/InstallerNSISInclude.nsh
+++ /dev/null
@@ -1,44 +0,0 @@
-!include "StrFunc.nsh"
-
-${StrFunction} StrContains ; Ensure that the StrContains function is imported
-
-; Function to append $INSTDIR to an environment variable if it's not already present
-Function UpdateEnvVar
-    ; Parameters: $R0 = Environment variable name
-    ReadRegStr $1 HKCU "Environment" $R0
-
-    ; Check if $INSTDIR is already in the environment variable
-    ${StrContains} $2 "$INSTDIR" "$1"
-
-    ; If $INSTDIR isn't in the environment variable, append it
-    ${If} $2 == ""
-        ; Check if the environment variable is empty. If it isn't, add a semicolon before appending
-        StrCmp $1 "" 0 +3
-        StrCpy $1 "$1;"
-        ; Append $INSTDIR to the environment variable
-        StrCpy $1 "$1$INSTDIR"
-        WriteRegStr HKCU 'Environment' $R0 "$1"
-        System::Call 'Kernel32::SetEnvironmentVariableA(t, t) i ($R0, "$1")'
-    ${EndIf}
-FunctionEnd
-
-; Set SENSING_DEV_ROOT and GST_PLUGIN_PATH directly to $INSTDIR
-WriteRegStr HKCU 'Environment' 'SENSING_DEV_ROOT' "$INSTDIR"
-System::Call 'Kernel32::SetEnvironmentVariableA(t, t) i ("SENSING_DEV_ROOT", "$INSTDIR")'
-
-WriteRegStr HKCU 'Environment' 'GST_PLUGIN_PATH' "$INSTDIR"
-System::Call 'Kernel32::SetEnvironmentVariableA(t, t) i ("GST_PLUGIN_PATH", "$INSTDIR")'
-
-; Update PYTHONPATH and PATH with $INSTDIR if needed
-Push "PYTHONPATH"
-Call UpdateEnvVar
-
-Push "Path"
-Call UpdateEnvVar
-
-; Notify the system of environment variable changes
-StrCpy $0 0 ; HWND_BROADCAST
-StrCpy $1 0x001A ; WM_SETTINGCHANGE
-StrCpy $2 0 ; wParam = NULL
-StrCpy $3 "Environment" ; lParam = "Environment"
-System::Call 'User32::SendMessageA(i,i,i,t) i ($0, $1, $2, $3)'
diff --git a/installer/cmake/PostInstallScript.cmake.in b/installer/cmake/PostInstallScript.cmake.in
deleted file mode 100644
index d3e99441..00000000
--- a/installer/cmake/PostInstallScript.cmake.in
+++ /dev/null
@@ -1,5 +0,0 @@
-# invoke_ps_install_template.cmake.in
-
-execute_process(COMMAND powershell.exe -ExecutionPolicy Bypass 
-                        -File "@PS_SCRIPT_PATH@" 
-                        -installPath "@INSTALLATION_DIR@")
diff --git a/installer/cmake/conan.cmake b/installer/cmake/conan.cmake
deleted file mode 100644
index e4a12a4d..00000000
--- a/installer/cmake/conan.cmake
+++ /dev/null
@@ -1,1027 +0,0 @@
-# The MIT License (MIT)
-
-# Copyright (c) 2018 JFrog
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-
-
-# This file comes from: https://github.com/conan-io/cmake-conan. Please refer
-# to this repository for issues and documentation.
-
-# Its purpose is to wrap and launch Conan C/C++ Package Manager when cmake is called.
-# It will take CMake current settings (os, compiler, compiler version, architecture)
-# and translate them to conan settings for installing and retrieving dependencies.
-
-# It is intended to facilitate developers building projects that have conan dependencies,
-# but it is only necessary on the end-user side. It is not necessary to create conan
-# packages, in fact it shouldn't be use for that. Check the project documentation.
-
-# version: 0.18.1
-
-include(CMakeParseArguments)
-
-function(_get_msvc_ide_version result)
-    set(${result} "" PARENT_SCOPE)
-    if(NOT MSVC_VERSION VERSION_LESS 1400 AND MSVC_VERSION VERSION_LESS 1500)
-        set(${result} 8 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1500 AND MSVC_VERSION VERSION_LESS 1600)
-        set(${result} 9 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1600 AND MSVC_VERSION VERSION_LESS 1700)
-        set(${result} 10 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1700 AND MSVC_VERSION VERSION_LESS 1800)
-        set(${result} 11 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1800 AND MSVC_VERSION VERSION_LESS 1900)
-        set(${result} 12 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1900 AND MSVC_VERSION VERSION_LESS 1910)
-        set(${result} 14 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1910 AND MSVC_VERSION VERSION_LESS 1920)
-        set(${result} 15 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930)
-        set(${result} 16 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940)
-        set(${result} 17 PARENT_SCOPE)
-    else()
-        message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]")
-    endif()
-endfunction()
-
-macro(_conan_detect_build_type)
-    conan_parse_arguments(${ARGV})
-
-    if(ARGUMENTS_BUILD_TYPE)
-        set(_CONAN_SETTING_BUILD_TYPE ${ARGUMENTS_BUILD_TYPE})
-    elseif(CMAKE_BUILD_TYPE)
-        set(_CONAN_SETTING_BUILD_TYPE ${CMAKE_BUILD_TYPE})
-    else()
-        message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)")
-    endif()
-
-    string(TOUPPER ${_CONAN_SETTING_BUILD_TYPE} _CONAN_SETTING_BUILD_TYPE_UPPER)
-    if (_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-        set(_CONAN_SETTING_BUILD_TYPE "Debug")
-    elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELEASE")
-        set(_CONAN_SETTING_BUILD_TYPE "Release")
-    elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELWITHDEBINFO")
-        set(_CONAN_SETTING_BUILD_TYPE "RelWithDebInfo")
-    elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "MINSIZEREL")
-        set(_CONAN_SETTING_BUILD_TYPE "MinSizeRel")
-    endif()
-endmacro()
-
-macro(_conan_check_system_name)
-    #handle -s os setting
-    if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic")
-        #use default conan os setting if CMAKE_SYSTEM_NAME is not defined
-        set(CONAN_SYSTEM_NAME ${CMAKE_SYSTEM_NAME})
-        if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-            set(CONAN_SYSTEM_NAME Macos)
-        endif()
-        if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX")
-            set(CONAN_SYSTEM_NAME Neutrino)
-        endif()
-        set(CONAN_SUPPORTED_PLATFORMS Windows Linux Macos Android iOS FreeBSD WindowsStore WindowsCE watchOS tvOS FreeBSD SunOS AIX Arduino Emscripten Neutrino)
-        list (FIND CONAN_SUPPORTED_PLATFORMS "${CONAN_SYSTEM_NAME}" _index)
-        if (${_index} GREATER -1)
-            #check if the cmake system is a conan supported one
-            set(_CONAN_SETTING_OS ${CONAN_SYSTEM_NAME})
-        else()
-            message(FATAL_ERROR "cmake system ${CONAN_SYSTEM_NAME} is not supported by conan. Use one of ${CONAN_SUPPORTED_PLATFORMS}")
-        endif()
-    endif()
-endmacro()
-
-macro(_conan_check_language)
-    get_property(_languages GLOBAL PROPERTY ENABLED_LANGUAGES)
-    if (";${_languages};" MATCHES ";CXX;")
-        set(LANGUAGE CXX)
-        set(USING_CXX 1)
-    elseif (";${_languages};" MATCHES ";C;")
-        set(LANGUAGE C)
-        set(USING_CXX 0)
-    else ()
-        message(FATAL_ERROR "Conan: Neither C or C++ was detected as a language for the project. Unabled to detect compiler version.")
-    endif()
-endmacro()
-
-macro(_conan_detect_compiler)
-
-    conan_parse_arguments(${ARGV})
-
-    if(ARGUMENTS_ARCH)
-        set(_CONAN_SETTING_ARCH ${ARGUMENTS_ARCH})
-    endif()
-
-    if(USING_CXX)
-        set(_CONAN_SETTING_COMPILER_CPPSTD ${CMAKE_CXX_STANDARD})
-    endif()
-
-    if (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL GNU)
-        # using GCC
-        # TODO: Handle other params
-        string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION})
-        list(GET VERSION_LIST 0 MAJOR)
-        list(GET VERSION_LIST 1 MINOR)
-        set(COMPILER_VERSION ${MAJOR}.${MINOR})
-        if(${MAJOR} GREATER 4)
-            set(COMPILER_VERSION ${MAJOR})
-        endif()
-        set(_CONAN_SETTING_COMPILER gcc)
-        set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION})
-        if (USING_CXX)
-            conan_cmake_detect_unix_libcxx(_LIBCXX)
-            set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
-        endif ()
-    elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Intel)
-        string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION})
-        list(GET VERSION_LIST 0 MAJOR)
-        list(GET VERSION_LIST 1 MINOR)
-        set(COMPILER_VERSION ${MAJOR}.${MINOR})
-        set(_CONAN_SETTING_COMPILER intel)
-        set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION})
-        if (USING_CXX)
-            conan_cmake_detect_unix_libcxx(_LIBCXX)
-            set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
-        endif ()
-    elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL AppleClang)
-        # using AppleClang
-        string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION})
-        list(GET VERSION_LIST 0 MAJOR)
-        list(GET VERSION_LIST 1 MINOR)
-        set(_CONAN_SETTING_COMPILER apple-clang)
-        set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR})
-        if (USING_CXX)
-            conan_cmake_detect_unix_libcxx(_LIBCXX)
-            set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
-        endif ()
-    elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang
-                AND NOT "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC" 
-                AND NOT "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC")
-
-        string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION})
-        list(GET VERSION_LIST 0 MAJOR)
-        list(GET VERSION_LIST 1 MINOR)
-        set(_CONAN_SETTING_COMPILER clang)
-        set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR})
-        if(APPLE)
-            cmake_policy(GET CMP0025 APPLE_CLANG_POLICY)
-            if(NOT APPLE_CLANG_POLICY STREQUAL NEW)
-                message(STATUS "Conan: APPLE and Clang detected. Assuming apple-clang compiler. Set CMP0025 to avoid it")
-                set(_CONAN_SETTING_COMPILER apple-clang)
-            endif()
-        endif()
-        if(${_CONAN_SETTING_COMPILER} STREQUAL clang AND ${MAJOR} GREATER 7)
-            set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR})
-        endif()
-        if (USING_CXX)
-            conan_cmake_detect_unix_libcxx(_LIBCXX)
-            set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
-        endif ()
-    elseif(${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL MSVC
-                OR (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang 
-                    AND "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC" 
-                    AND "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC"))
-
-        # set(_VISUAL "Visual Studio")
-        set(_VISUAL "Visual Studio")
-        _get_msvc_ide_version(_VISUAL_VERSION)
-        if("${_VISUAL_VERSION}" STREQUAL "")
-            message(FATAL_ERROR "Conan: Visual Studio not recognized")
-        else()
-            set(_CONAN_SETTING_COMPILER ${_VISUAL})
-            set(_CONAN_SETTING_COMPILER_VERSION ${_VISUAL_VERSION})
-        endif()
-
-        if(NOT _CONAN_SETTING_ARCH)
-            if (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "64")
-                set(_CONAN_SETTING_ARCH x86_64)
-            elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "^ARM")
-                message(STATUS "Conan: Using default ARM architecture from MSVC")
-                set(_CONAN_SETTING_ARCH armv6)
-            elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "86")
-                set(_CONAN_SETTING_ARCH x86)
-            else ()
-                message(FATAL_ERROR "Conan: Unknown MSVC architecture [${MSVC_${LANGUAGE}_ARCHITECTURE_ID}]")
-            endif()
-        endif()
-
-        conan_cmake_detect_vs_runtime(_vs_runtime ${ARGV})
-        message(STATUS "Conan: Detected VS runtime: ${_vs_runtime}")
-        set(_CONAN_SETTING_COMPILER_RUNTIME ${_vs_runtime})
-
-        if (CMAKE_GENERATOR_TOOLSET)
-            set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET})
-        elseif(CMAKE_VS_PLATFORM_TOOLSET AND (CMAKE_GENERATOR STREQUAL "Ninja"))
-            set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET})
-        endif()
-        else()
-        message(FATAL_ERROR "Conan: compiler setup not recognized")
-    endif()
-
-endmacro()
-
-function(conan_cmake_settings result)
-    #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER})
-    #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER_ID})
-    #message(STATUS "VERSION " ${CMAKE_CXX_COMPILER_VERSION})
-    #message(STATUS "FLAGS " ${CMAKE_LANG_FLAGS})
-    #message(STATUS "LIB ARCH " ${CMAKE_CXX_LIBRARY_ARCHITECTURE})
-    #message(STATUS "BUILD TYPE " ${CMAKE_BUILD_TYPE})
-    #message(STATUS "GENERATOR " ${CMAKE_GENERATOR})
-    #message(STATUS "GENERATOR WIN64 " ${CMAKE_CL_64})
-
-    message(STATUS "Conan: Automatic detection of conan settings from cmake")
-
-    conan_parse_arguments(${ARGV})
-
-    _conan_detect_build_type(${ARGV})
-
-    _conan_check_system_name()
-
-    _conan_check_language()
-
-    _conan_detect_compiler(${ARGV})
-
-    # If profile is defined it is used
-    if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ARGUMENTS_DEBUG_PROFILE)
-        set(_APPLIED_PROFILES ${ARGUMENTS_DEBUG_PROFILE})
-    elseif(CMAKE_BUILD_TYPE STREQUAL "Release" AND ARGUMENTS_RELEASE_PROFILE)
-        set(_APPLIED_PROFILES ${ARGUMENTS_RELEASE_PROFILE})
-    elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" AND ARGUMENTS_RELWITHDEBINFO_PROFILE)
-        set(_APPLIED_PROFILES ${ARGUMENTS_RELWITHDEBINFO_PROFILE})
-    elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" AND ARGUMENTS_MINSIZEREL_PROFILE)
-        set(_APPLIED_PROFILES ${ARGUMENTS_MINSIZEREL_PROFILE})
-    elseif(ARGUMENTS_PROFILE)
-        set(_APPLIED_PROFILES ${ARGUMENTS_PROFILE})
-    endif()
-
-    foreach(ARG ${_APPLIED_PROFILES})
-        set(_SETTINGS ${_SETTINGS} -pr=${ARG})
-    endforeach()
-    foreach(ARG ${ARGUMENTS_PROFILE_BUILD})
-        conan_check(VERSION 1.24.0 REQUIRED DETECT_QUIET)
-        set(_SETTINGS ${_SETTINGS} -pr:b=${ARG})
-    endforeach()
-
-    if(NOT _SETTINGS OR ARGUMENTS_PROFILE_AUTO STREQUAL "ALL")
-        set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version
-                                   compiler.runtime compiler.libcxx compiler.toolset)
-    endif()
-
-    # remove any manually specified settings from the autodetected settings
-    foreach(ARG ${ARGUMENTS_SETTINGS})
-        string(REGEX MATCH "[^=]*" MANUAL_SETTING "${ARG}")
-        message(STATUS "Conan: ${MANUAL_SETTING} was added as an argument. Not using the autodetected one.")
-        list(REMOVE_ITEM ARGUMENTS_PROFILE_AUTO "${MANUAL_SETTING}")
-    endforeach()
-
-    # Automatic from CMake
-    foreach(ARG ${ARGUMENTS_PROFILE_AUTO})
-        string(TOUPPER ${ARG} _arg_name)
-        string(REPLACE "." "_" _arg_name ${_arg_name})
-        if(_CONAN_SETTING_${_arg_name})
-            set(_SETTINGS ${_SETTINGS} -s ${ARG}=${_CONAN_SETTING_${_arg_name}})
-        endif()
-    endforeach()
-
-    foreach(ARG ${ARGUMENTS_SETTINGS})
-        set(_SETTINGS ${_SETTINGS} -s ${ARG})
-    endforeach()
-
-    message(STATUS "Conan: Settings= ${_SETTINGS}")
-
-    set(${result} ${_SETTINGS} PARENT_SCOPE)
-endfunction()
-
-
-function(conan_cmake_detect_unix_libcxx result)
-    # Take into account any -stdlib in compile options
-    get_directory_property(compile_options DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS)
-    string(GENEX_STRIP "${compile_options}" compile_options)
-
-    # Take into account any _GLIBCXX_USE_CXX11_ABI in compile definitions
-    get_directory_property(defines DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS)
-    string(GENEX_STRIP "${defines}" defines)
-
-    foreach(define ${defines})
-        if(define MATCHES "_GLIBCXX_USE_CXX11_ABI")
-            if(define MATCHES "^-D")
-                set(compile_options ${compile_options} "${define}")
-            else()
-                set(compile_options ${compile_options} "-D${define}")
-            endif()
-        endif()
-    endforeach()
-
-    # add additional compiler options ala cmRulePlaceholderExpander::ExpandRuleVariable
-    set(EXPAND_CXX_COMPILER ${CMAKE_CXX_COMPILER})
-    if(CMAKE_CXX_COMPILER_ARG1)
-        # CMake splits CXX="foo bar baz" into CMAKE_CXX_COMPILER="foo", CMAKE_CXX_COMPILER_ARG1="bar baz"
-        # without this, ccache, winegcc, or other wrappers might lose all their arguments
-        separate_arguments(SPLIT_CXX_COMPILER_ARG1 NATIVE_COMMAND ${CMAKE_CXX_COMPILER_ARG1})
-        list(APPEND EXPAND_CXX_COMPILER ${SPLIT_CXX_COMPILER_ARG1})
-    endif()
-
-    if(CMAKE_CXX_COMPILE_OPTIONS_TARGET AND CMAKE_CXX_COMPILER_TARGET)
-        # without --target= we may be calling the wrong underlying GCC
-        list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}")
-    endif()
-
-    if(CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN AND CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN)
-        list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
-    endif()
-
-    if(CMAKE_CXX_COMPILE_OPTIONS_SYSROOT)
-        # without --sysroot= we may find the wrong #include <string>
-        if(CMAKE_SYSROOT_COMPILE)
-            list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT_COMPILE}")
-        elseif(CMAKE_SYSROOT)
-            list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}")
-        endif()
-    endif()
-
-    separate_arguments(SPLIT_CXX_FLAGS NATIVE_COMMAND ${CMAKE_CXX_FLAGS})
-
-    if(CMAKE_OSX_SYSROOT)
-        set(xcode_sysroot_option "--sysroot=${CMAKE_OSX_SYSROOT}")
-    endif()
-
-    execute_process(
-        COMMAND ${CMAKE_COMMAND} -E echo "#include <string>"
-        COMMAND ${EXPAND_CXX_COMPILER} ${SPLIT_CXX_FLAGS} -x c++ ${xcode_sysroot_option} ${compile_options} -E -dM -
-        OUTPUT_VARIABLE string_defines
-    )
-
-    if(string_defines MATCHES "#define __GLIBCXX__")
-        # Allow -D_GLIBCXX_USE_CXX11_ABI=ON/OFF as argument to cmake
-        if(DEFINED _GLIBCXX_USE_CXX11_ABI)
-            if(_GLIBCXX_USE_CXX11_ABI)
-                set(${result} libstdc++11 PARENT_SCOPE)
-                return()
-            else()
-                set(${result} libstdc++ PARENT_SCOPE)
-                return()
-            endif()
-        endif()
-
-        if(string_defines MATCHES "#define _GLIBCXX_USE_CXX11_ABI 1\n")
-            set(${result} libstdc++11 PARENT_SCOPE)
-        else()
-            # Either the compiler is missing the define because it is old, and so
-            # it can't use the new abi, or the compiler was configured to use the
-            # old abi by the user or distro (e.g. devtoolset on RHEL/CentOS)
-            set(${result} libstdc++ PARENT_SCOPE)
-        endif()
-    else()
-        set(${result} libc++ PARENT_SCOPE)
-    endif()
-endfunction()
-
-function(conan_cmake_detect_vs_runtime result)
-
-    conan_parse_arguments(${ARGV})
-    if(ARGUMENTS_BUILD_TYPE)
-        set(build_type "${ARGUMENTS_BUILD_TYPE}")
-    elseif(CMAKE_BUILD_TYPE)
-        set(build_type "${CMAKE_BUILD_TYPE}")
-    else()
-        message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)")
-    endif()
-
-    if(build_type)
-        string(TOUPPER "${build_type}" build_type)
-    endif()
-    set(variables CMAKE_CXX_FLAGS_${build_type} CMAKE_C_FLAGS_${build_type} CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
-    foreach(variable ${variables})
-        if(NOT "${${variable}}" STREQUAL "")
-            string(REPLACE " " ";" flags "${${variable}}")
-            foreach (flag ${flags})
-                if("${flag}" STREQUAL "/MD" OR "${flag}" STREQUAL "/MDd" OR "${flag}" STREQUAL "/MT" OR "${flag}" STREQUAL "/MTd")
-                    string(SUBSTRING "${flag}" 1 -1 runtime)
-                    set(${result} "${runtime}" PARENT_SCOPE)
-                    return()
-                endif()
-            endforeach()
-        endif()
-    endforeach()
-    if("${build_type}" STREQUAL "DEBUG")
-        set(${result} "MDd" PARENT_SCOPE)
-    else()
-        set(${result} "MD" PARENT_SCOPE)
-    endif()
-endfunction()
-
-function(_collect_settings result)
-    set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version
-                            compiler.runtime compiler.libcxx compiler.toolset
-                            compiler.cppstd)
-    foreach(ARG ${ARGUMENTS_PROFILE_AUTO})
-        string(TOUPPER ${ARG} _arg_name)
-        string(REPLACE "." "_" _arg_name ${_arg_name})
-        if(_CONAN_SETTING_${_arg_name})
-            set(detected_setings ${detected_setings} ${ARG}=${_CONAN_SETTING_${_arg_name}})
-        endif()
-    endforeach()
-    set(${result} ${detected_setings} PARENT_SCOPE)
-endfunction()
-
-function(conan_cmake_autodetect detected_settings)
-    _conan_detect_build_type(${ARGV})
-    _conan_check_system_name()
-    _conan_check_language()
-    _conan_detect_compiler(${ARGV})
-    _collect_settings(collected_settings)
-    set(${detected_settings} ${collected_settings} PARENT_SCOPE)
-endfunction()
-
-macro(conan_parse_arguments)
-  set(options BASIC_SETUP CMAKE_TARGETS UPDATE KEEP_RPATHS NO_LOAD NO_OUTPUT_DIRS OUTPUT_QUIET NO_IMPORTS SKIP_STD)
-  set(oneValueArgs CONANFILE  ARCH BUILD_TYPE INSTALL_FOLDER OUTPUT_FOLDER CONAN_COMMAND)
-  set(multiValueArgs DEBUG_PROFILE RELEASE_PROFILE RELWITHDEBINFO_PROFILE MINSIZEREL_PROFILE
-                     PROFILE REQUIRES OPTIONS IMPORTS SETTINGS BUILD ENV GENERATORS PROFILE_AUTO
-                     INSTALL_ARGS CONFIGURATION_TYPES PROFILE_BUILD BUILD_REQUIRES)
-  cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-endmacro()
-
-function(old_conan_cmake_install)
-    # Calls "conan install"
-    # Argument BUILD is equivalant to --build={missing, PkgName,...} or
-    # --build when argument is 'BUILD all' (which builds all packages from source)
-    # Argument CONAN_COMMAND, to specify the conan path, e.g. in case of running from source
-    # cmake does not identify conan as command, even if it is +x and it is in the path
-    conan_parse_arguments(${ARGV})
-
-    if(CONAN_CMAKE_MULTI)
-        set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake_multi)
-    else()
-        set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake)
-    endif()
-
-    set(CONAN_BUILD_POLICY "")
-    foreach(ARG ${ARGUMENTS_BUILD})
-        if(${ARG} STREQUAL "all")
-            set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build)
-            break()
-        else()
-            set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build=${ARG})
-        endif()
-    endforeach()
-    if(ARGUMENTS_CONAN_COMMAND)
-       set(CONAN_CMD ${ARGUMENTS_CONAN_COMMAND})
-    else()
-        conan_check(REQUIRED)
-    endif()
-    set(CONAN_OPTIONS "")
-    if(ARGUMENTS_CONANFILE)
-      if(IS_ABSOLUTE ${ARGUMENTS_CONANFILE})
-          set(CONANFILE ${ARGUMENTS_CONANFILE})
-      else()
-          set(CONANFILE ${CMAKE_CURRENT_SOURCE_DIR}/${ARGUMENTS_CONANFILE})
-      endif()
-    else()
-      set(CONANFILE ".")
-    endif()
-    foreach(ARG ${ARGUMENTS_OPTIONS})
-      set(CONAN_OPTIONS ${CONAN_OPTIONS} -o=${ARG})
-    endforeach()
-    if(ARGUMENTS_UPDATE)
-      set(CONAN_INSTALL_UPDATE --update)
-    endif()
-    if(ARGUMENTS_NO_IMPORTS)
-      set(CONAN_INSTALL_NO_IMPORTS --no-imports)
-    endif()
-    set(CONAN_INSTALL_FOLDER "")
-    if(ARGUMENTS_INSTALL_FOLDER)
-      set(CONAN_INSTALL_FOLDER -if=${ARGUMENTS_INSTALL_FOLDER})
-    endif()
-    set(CONAN_OUTPUT_FOLDER "")
-    if(ARGUMENTS_OUTPUT_FOLDER)
-      set(CONAN_OUTPUT_FOLDER -of=${ARGUMENTS_OUTPUT_FOLDER})
-    endif()
-    foreach(ARG ${ARGUMENTS_GENERATORS})
-        set(CONAN_GENERATORS ${CONAN_GENERATORS} -g=${ARG})
-    endforeach()
-    foreach(ARG ${ARGUMENTS_ENV})
-        set(CONAN_ENV_VARS ${CONAN_ENV_VARS} -e=${ARG})
-    endforeach()
-    set(conan_args install ${CONANFILE} ${settings} ${CONAN_ENV_VARS} ${CONAN_GENERATORS} ${CONAN_BUILD_POLICY} ${CONAN_INSTALL_UPDATE} ${CONAN_INSTALL_NO_IMPORTS} ${CONAN_OPTIONS} ${CONAN_INSTALL_FOLDER} ${ARGUMENTS_INSTALL_ARGS})
-
-    string (REPLACE ";" " " _conan_args "${conan_args}")
-    message(STATUS "Conan executing: ${CONAN_CMD} ${_conan_args}")
-
-    if(ARGUMENTS_OUTPUT_QUIET)
-        execute_process(COMMAND ${CONAN_CMD} ${conan_args}
-                        RESULT_VARIABLE return_code
-                        OUTPUT_VARIABLE conan_output
-                        ERROR_VARIABLE conan_output
-                        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-    else()
-        execute_process(COMMAND ${CONAN_CMD} ${conan_args}
-                        RESULT_VARIABLE return_code
-                        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-    endif()
-
-    if(NOT "${return_code}" STREQUAL "0")
-      message(FATAL_ERROR "Conan install failed='${return_code}'")
-    endif()
-
-endfunction()
-
-function(conan_cmake_install)
-    if(DEFINED CONAN_COMMAND)
-        set(CONAN_CMD ${CONAN_COMMAND})
-    else()
-        conan_check(REQUIRED)
-    endif()
-
-    set(installOptions UPDATE NO_IMPORTS OUTPUT_QUIET ERROR_QUIET)
-    set(installOneValueArgs PATH_OR_REFERENCE REFERENCE REMOTE LOCKFILE LOCKFILE_OUT LOCKFILE_NODE_ID INSTALL_FOLDER OUTPUT_FOLDER)
-    set(installMultiValueArgs GENERATOR BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE
-                              PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD)
-    cmake_parse_arguments(ARGS "${installOptions}" "${installOneValueArgs}" "${installMultiValueArgs}" ${ARGN})
-    foreach(arg ${installOptions})
-        if(ARGS_${arg})
-            set(${arg} ${${arg}} ${ARGS_${arg}})
-        endif()
-    endforeach()
-    foreach(arg ${installOneValueArgs})
-        if(DEFINED ARGS_${arg})
-            if("${arg}" STREQUAL "REMOTE")
-                set(flag "--remote")
-            elseif("${arg}" STREQUAL "LOCKFILE")
-                set(flag "--lockfile")
-            elseif("${arg}" STREQUAL "LOCKFILE_OUT")
-                set(flag "--lockfile-out")
-            elseif("${arg}" STREQUAL "LOCKFILE_NODE_ID")
-                set(flag "--lockfile-node-id")
-            elseif("${arg}" STREQUAL "INSTALL_FOLDER")
-                set(flag "--install-folder")
-            elseif("${arg}" STREQUAL "OUTPUT_FOLDER")
-                set(flag "--output-folder")
-            endif()
-            set(${arg} ${${arg}} ${flag} ${ARGS_${arg}})
-        endif()
-    endforeach()
-    foreach(arg ${installMultiValueArgs})
-        if(DEFINED ARGS_${arg})
-            if("${arg}" STREQUAL "GENERATOR")
-                set(flag "--generator")
-            elseif("${arg}" STREQUAL "BUILD")
-                set(flag "--build")
-            elseif("${arg}" STREQUAL "ENV")
-                set(flag "--env")
-            elseif("${arg}" STREQUAL "ENV_HOST")
-                set(flag "--env:host")
-            elseif("${arg}" STREQUAL "ENV_BUILD")
-                set(flag "--env:build")
-            elseif("${arg}" STREQUAL "OPTIONS")
-                set(flag "--options")
-            elseif("${arg}" STREQUAL "OPTIONS_HOST")
-                set(flag "--options:host")
-            elseif("${arg}" STREQUAL "OPTIONS_BUILD")
-                set(flag "--options:build")
-            elseif("${arg}" STREQUAL "PROFILE")
-                set(flag "--profile")
-            elseif("${arg}" STREQUAL "PROFILE_HOST")
-                set(flag "--profile:host")
-            elseif("${arg}" STREQUAL "PROFILE_BUILD")
-                set(flag "--profile:build")
-            elseif("${arg}" STREQUAL "SETTINGS")
-                set(flag "--settings")
-            elseif("${arg}" STREQUAL "SETTINGS_HOST")
-                set(flag "--settings:host")
-            elseif("${arg}" STREQUAL "SETTINGS_BUILD")
-                set(flag "--settings:build")
-            endif()
-            list(LENGTH ARGS_${arg} numargs)
-            foreach(item ${ARGS_${arg}})
-                if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD")
-                    set(${arg} "--build")
-                    break()
-                endif()
-                set(${arg} ${${arg}} ${flag} ${item})
-            endforeach()
-        endif()
-    endforeach()
-    if(DEFINED UPDATE)
-        set(UPDATE --update)
-    endif()
-    if(DEFINED NO_IMPORTS)
-        set(NO_IMPORTS --no-imports)
-    endif()
-    set(install_args install ${PATH_OR_REFERENCE} ${REFERENCE} ${UPDATE} ${NO_IMPORTS} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER} ${OUTPUT_FOLDER}
-                                ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD}
-                                ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD})
-
-    string(REPLACE ";" " " _install_args "${install_args}")
-    message(STATUS "Conan executing: ${CONAN_CMD} ${_install_args}")
-
-    if(ARGS_OUTPUT_QUIET)
-      set(OUTPUT_OPT OUTPUT_QUIET)
-    endif()
-    if(ARGS_ERROR_QUIET)
-      set(ERROR_OPT ERROR_QUIET)
-    endif()
-
-    execute_process(COMMAND ${CONAN_CMD} ${install_args}
-                    RESULT_VARIABLE return_code
-                    ${OUTPUT_OPT}
-                    ${ERROR_OPT}
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
-    if(NOT "${return_code}" STREQUAL "0")
-        if (ARGS_ERROR_QUIET)
-            message(WARNING "Conan install failed='${return_code}'")
-        else()
-            message(FATAL_ERROR "Conan install failed='${return_code}'")
-        endif()
-    endif()
-
-endfunction()
-
-function(conan_cmake_lock_create)
-    if(DEFINED CONAN_COMMAND)
-        set(CONAN_CMD ${CONAN_COMMAND})
-    else()
-        conan_check(REQUIRED)
-    endif()
-
-    set(lockCreateOptions UPDATE BASE OUTPUT_QUIET ERROR_QUIET)
-    set(lockCreateOneValueArgs PATH REFERENCE REMOTE LOCKFILE LOCKFILE_OUT)
-    set(lockCreateMultiValueArgs BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE
-                              PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD)
-    cmake_parse_arguments(ARGS "${lockCreateOptions}" "${lockCreateOneValueArgs}" "${lockCreateMultiValueArgs}" ${ARGN})
-    foreach(arg ${lockCreateOptions})
-        if(ARGS_${arg})
-            set(${arg} ${${arg}} ${ARGS_${arg}})
-        endif()
-    endforeach()
-    foreach(arg ${lockCreateOneValueArgs})
-        if(DEFINED ARGS_${arg})
-            if("${arg}" STREQUAL "REMOTE")
-                set(flag "--remote")
-            elseif("${arg}" STREQUAL "LOCKFILE")
-                set(flag "--lockfile")
-            elseif("${arg}" STREQUAL "LOCKFILE_OUT")
-                set(flag "--lockfile-out")
-            endif()
-            set(${arg} ${${arg}} ${flag} ${ARGS_${arg}})
-        endif()
-    endforeach()
-    foreach(arg ${lockCreateMultiValueArgs})
-        if(DEFINED ARGS_${arg})
-            if("${arg}" STREQUAL "BUILD")
-                set(flag "--build")
-            elseif("${arg}" STREQUAL "ENV")
-                set(flag "--env")
-            elseif("${arg}" STREQUAL "ENV_HOST")
-                set(flag "--env:host")
-            elseif("${arg}" STREQUAL "ENV_BUILD")
-                set(flag "--env:build")
-            elseif("${arg}" STREQUAL "OPTIONS")
-                set(flag "--options")
-            elseif("${arg}" STREQUAL "OPTIONS_HOST")
-                set(flag "--options:host")
-            elseif("${arg}" STREQUAL "OPTIONS_BUILD")
-                set(flag "--options:build")
-            elseif("${arg}" STREQUAL "PROFILE")
-                set(flag "--profile")
-            elseif("${arg}" STREQUAL "PROFILE_HOST")
-                set(flag "--profile:host")
-            elseif("${arg}" STREQUAL "PROFILE_BUILD")
-                set(flag "--profile:build")
-            elseif("${arg}" STREQUAL "SETTINGS")
-                set(flag "--settings")
-            elseif("${arg}" STREQUAL "SETTINGS_HOST")
-                set(flag "--settings:host")
-            elseif("${arg}" STREQUAL "SETTINGS_BUILD")
-                set(flag "--settings:build")
-            endif()
-            list(LENGTH ARGS_${arg} numargs)
-            foreach(item ${ARGS_${arg}})
-                if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD")
-                    set(${arg} "--build")
-                    break()
-                endif()
-                set(${arg} ${${arg}} ${flag} ${item})
-            endforeach()
-        endif()
-    endforeach()
-    if(DEFINED UPDATE)
-        set(UPDATE --update)
-    endif()
-    if(DEFINED BASE)
-        set(BASE --base)
-    endif()
-    set(lock_create_Args lock create ${PATH} ${REFERENCE} ${UPDATE} ${BASE} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER}
-                                ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD} 
-                                ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD})
-
-    string(REPLACE ";" " " _lock_create_Args "${lock_create_Args}")
-    message(STATUS "Conan executing: ${CONAN_CMD} ${_lock_create_Args}")
-    
-    if(ARGS_OUTPUT_QUIET)
-      set(OUTPUT_OPT OUTPUT_QUIET)
-    endif()
-    if(ARGS_ERROR_QUIET)
-      set(ERROR_OPT ERROR_QUIET)
-    endif()
-
-    execute_process(COMMAND ${CONAN_CMD} ${lock_create_Args}
-                    RESULT_VARIABLE return_code
-                    ${OUTPUT_OPT}
-                    ${ERROR_OPT}
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
-    if(NOT "${return_code}" STREQUAL "0")
-        if (ARGS_ERROR_QUIET)
-            message(WARNING "Conan lock create failed='${return_code}'")
-        else()
-            message(FATAL_ERROR "Conan lock create failed='${return_code}'")
-        endif()
-    endif()
-endfunction()
-
-function(conan_cmake_setup_conanfile)
-  conan_parse_arguments(${ARGV})
-  if(ARGUMENTS_CONANFILE)
-    get_filename_component(_CONANFILE_NAME ${ARGUMENTS_CONANFILE} NAME)
-    # configure_file will make sure cmake re-runs when conanfile is updated
-    configure_file(${ARGUMENTS_CONANFILE} ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk COPYONLY)
-    file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk)
-  else()
-    conan_cmake_generate_conanfile(ON ${ARGV})
-  endif()
-endfunction()
-
-function(conan_cmake_configure)
-    conan_cmake_generate_conanfile(OFF ${ARGV})
-endfunction()
-
-# Generate, writing in disk a conanfile.txt with the requires, options, and imports
-# specified as arguments
-# This will be considered as temporary file, generated in CMAKE_CURRENT_BINARY_DIR)
-function(conan_cmake_generate_conanfile DEFAULT_GENERATOR)
-
-    conan_parse_arguments(${ARGV})
-
-    set(_FN "${CMAKE_CURRENT_BINARY_DIR}/conanfile.txt")
-    file(WRITE ${_FN} "")
-
-    if(DEFINED ARGUMENTS_REQUIRES)
-        file(APPEND ${_FN} "[requires]\n")
-        foreach(REQUIRE ${ARGUMENTS_REQUIRES})
-            file(APPEND ${_FN} ${REQUIRE} "\n")
-        endforeach()
-    endif()
-
-    if (DEFAULT_GENERATOR OR DEFINED ARGUMENTS_GENERATORS)
-        file(APPEND ${_FN} "[generators]\n")
-        if (DEFAULT_GENERATOR)
-            file(APPEND ${_FN} "cmake\n")
-        endif()
-        if (DEFINED ARGUMENTS_GENERATORS)
-            foreach(GENERATOR ${ARGUMENTS_GENERATORS})
-                file(APPEND ${_FN} ${GENERATOR} "\n")
-            endforeach()
-        endif()
-    endif()
-
-    if(DEFINED ARGUMENTS_BUILD_REQUIRES)
-        file(APPEND ${_FN} "[build_requires]\n")
-        foreach(BUILD_REQUIRE ${ARGUMENTS_BUILD_REQUIRES})
-            file(APPEND ${_FN} ${BUILD_REQUIRE} "\n")
-        endforeach()
-    endif()
-
-    if(DEFINED ARGUMENTS_IMPORTS)
-        file(APPEND ${_FN} "[imports]\n")
-        foreach(IMPORTS ${ARGUMENTS_IMPORTS})
-            file(APPEND ${_FN} ${IMPORTS} "\n")
-        endforeach()
-    endif()
-
-    if(DEFINED ARGUMENTS_OPTIONS)
-        file(APPEND ${_FN} "[options]\n")
-        foreach(OPTION ${ARGUMENTS_OPTIONS})
-            file(APPEND ${_FN} ${OPTION} "\n")
-        endforeach()
-    endif()
-
-endfunction()
-
-
-macro(conan_load_buildinfo)
-    if(CONAN_CMAKE_MULTI)
-      set(_CONANBUILDINFO conanbuildinfo_multi.cmake)
-    else()
-      set(_CONANBUILDINFO conanbuildinfo.cmake)
-    endif()
-    if(ARGUMENTS_INSTALL_FOLDER)
-        set(_CONANBUILDINFOFOLDER ${ARGUMENTS_INSTALL_FOLDER})
-    else()
-        set(_CONANBUILDINFOFOLDER ${CMAKE_CURRENT_BINARY_DIR})
-    endif()
-    # Checks for the existence of conanbuildinfo.cmake, and loads it
-    # important that it is macro, so variables defined at parent scope
-    if(EXISTS "${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}")
-      message(STATUS "Conan: Loading ${_CONANBUILDINFO}")
-      include(${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO})
-    else()
-      message(FATAL_ERROR "${_CONANBUILDINFO} doesn't exist in ${CMAKE_CURRENT_BINARY_DIR}")
-    endif()
-endmacro()
-
-
-macro(conan_cmake_run)
-    conan_parse_arguments(${ARGV})
-
-    if(ARGUMENTS_CONFIGURATION_TYPES AND NOT CMAKE_CONFIGURATION_TYPES)
-        message(WARNING "CONFIGURATION_TYPES should only be specified for multi-configuration generators")
-    elseif(ARGUMENTS_CONFIGURATION_TYPES AND ARGUMENTS_BUILD_TYPE)
-        message(WARNING "CONFIGURATION_TYPES and BUILD_TYPE arguments should not be defined at the same time.")
-    endif()
-
-    if(CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE AND NOT CONAN_EXPORTED
-            AND NOT ARGUMENTS_BUILD_TYPE)
-        set(CONAN_CMAKE_MULTI ON)
-        if (NOT ARGUMENTS_CONFIGURATION_TYPES)
-            set(ARGUMENTS_CONFIGURATION_TYPES "Release;Debug")
-        endif()
-        message(STATUS "Conan: Using cmake-multi generator")
-    else()
-        set(CONAN_CMAKE_MULTI OFF)
-    endif()
-
-    if(NOT CONAN_EXPORTED)
-        conan_cmake_setup_conanfile(${ARGV})
-        if(CONAN_CMAKE_MULTI)
-            foreach(CMAKE_BUILD_TYPE ${ARGUMENTS_CONFIGURATION_TYPES})
-                set(ENV{CONAN_IMPORT_PATH} ${CMAKE_BUILD_TYPE})
-                conan_cmake_settings(settings ${ARGV})
-                old_conan_cmake_install(SETTINGS ${settings} ${ARGV})
-            endforeach()
-            set(CMAKE_BUILD_TYPE)
-        else()
-            conan_cmake_settings(settings ${ARGV})
-            old_conan_cmake_install(SETTINGS ${settings} ${ARGV})
-        endif()
-    endif()
-
-    if (NOT ARGUMENTS_NO_LOAD)
-      conan_load_buildinfo()
-    endif()
-
-    if(ARGUMENTS_BASIC_SETUP)
-        foreach(_option CMAKE_TARGETS KEEP_RPATHS NO_OUTPUT_DIRS SKIP_STD)
-            if(ARGUMENTS_${_option})
-                if(${_option} STREQUAL "CMAKE_TARGETS")
-                    list(APPEND _setup_options "TARGETS")
-                else()
-                    list(APPEND _setup_options ${_option})
-                endif()
-            endif()
-        endforeach()
-        conan_basic_setup(${_setup_options})
-    endif()
-endmacro()
-
-macro(conan_check)
-    # Checks conan availability in PATH
-    # Arguments REQUIRED, DETECT_QUIET and VERSION are optional
-    # Example usage:
-    #    conan_check(VERSION 1.0.0 REQUIRED)
-    set(options REQUIRED DETECT_QUIET)
-    set(oneValueArgs VERSION)
-    cmake_parse_arguments(CONAN "${options}" "${oneValueArgs}" "" ${ARGN})
-    if(NOT CONAN_DETECT_QUIET)
-        message(STATUS "Conan: checking conan executable")
-    endif()
-
-    find_program(CONAN_CMD conan)
-    if(NOT CONAN_CMD AND CONAN_REQUIRED)
-        message(FATAL_ERROR "Conan executable not found! Please install conan.")
-    endif()
-    if(NOT CONAN_DETECT_QUIET)
-        message(STATUS "Conan: Found program ${CONAN_CMD}")
-    endif()
-    execute_process(COMMAND ${CONAN_CMD} --version
-                    RESULT_VARIABLE return_code
-                    OUTPUT_VARIABLE CONAN_VERSION_OUTPUT
-                    ERROR_VARIABLE CONAN_VERSION_OUTPUT)
-
-    if(NOT "${return_code}" STREQUAL "0")
-      message(FATAL_ERROR "Conan --version failed='${return_code}'")
-    endif()
-
-    if(NOT CONAN_DETECT_QUIET)
-        string(STRIP "${CONAN_VERSION_OUTPUT}" _CONAN_VERSION_OUTPUT)
-        message(STATUS "Conan: Version found ${_CONAN_VERSION_OUTPUT}")
-    endif()
-
-    if(DEFINED CONAN_VERSION)
-        string(REGEX MATCH ".*Conan version ([0-9]+\\.[0-9]+\\.[0-9]+)" FOO
-            "${CONAN_VERSION_OUTPUT}")
-        if(${CMAKE_MATCH_1} VERSION_LESS ${CONAN_VERSION})
-            message(FATAL_ERROR "Conan outdated. Installed: ${CMAKE_MATCH_1}, \
-                required: ${CONAN_VERSION}. Consider updating via 'pip \
-                install conan==${CONAN_VERSION}'.")
-        endif()
-    endif()
-endmacro()
-
-function(conan_add_remote)
-    # Adds a remote
-    # Arguments URL and NAME are required, INDEX, COMMAND and VERIFY_SSL are optional
-    # Example usage:
-    #    conan_add_remote(NAME bincrafters INDEX 1
-    #       URL https://api.bintray.com/conan/bincrafters/public-conan
-    #       VERIFY_SSL True)
-    set(oneValueArgs URL NAME INDEX COMMAND VERIFY_SSL)
-    cmake_parse_arguments(CONAN "" "${oneValueArgs}" "" ${ARGN})
-
-    if(DEFINED CONAN_INDEX)
-        set(CONAN_INDEX_ARG "-i ${CONAN_INDEX}")
-    endif()
-    if(DEFINED CONAN_COMMAND)
-        set(CONAN_CMD ${CONAN_COMMAND})
-    else()
-        conan_check(REQUIRED DETECT_QUIET)
-    endif()
-    set(CONAN_VERIFY_SSL_ARG "True")
-    if(DEFINED CONAN_VERIFY_SSL)
-        set(CONAN_VERIFY_SSL_ARG ${CONAN_VERIFY_SSL})
-    endif()
-    message(STATUS "Conan: Adding ${CONAN_NAME} remote repository (${CONAN_URL}) verify ssl (${CONAN_VERIFY_SSL_ARG})")
-    execute_process(COMMAND ${CONAN_CMD} remote add ${CONAN_NAME} ${CONAN_INDEX_ARG} -f ${CONAN_URL} ${CONAN_VERIFY_SSL_ARG}
-                    RESULT_VARIABLE return_code)
-    if(NOT "${return_code}" STREQUAL "0")
-      message(FATAL_ERROR "Conan remote failed='${return_code}'")
-    endif()
-endfunction()
-
-macro(conan_config_install)
-    # install a full configuration from a local or remote zip file
-    # Argument ITEM is required, arguments TYPE, SOURCE, TARGET and VERIFY_SSL are optional
-    # Example usage:
-    #    conan_config_install(ITEM https://github.com/conan-io/cmake-conan.git
-    #       TYPE git SOURCE source-folder TARGET target-folder VERIFY_SSL false)
-    set(oneValueArgs ITEM TYPE SOURCE TARGET VERIFY_SSL)
-    set(multiValueArgs ARGS)
-    cmake_parse_arguments(CONAN "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-    if(DEFINED CONAN_COMMAND)
-        set(CONAN_CMD ${CONAN_COMMAND})
-    else()
-        conan_check(REQUIRED)
-    endif()
-
-    if(DEFINED CONAN_VERIFY_SSL)
-	set(CONAN_VERIFY_SSL_ARG "--verify-ssl=${CONAN_VERIFY_SSL}")
-    endif()
-
-    if(DEFINED CONAN_TYPE)
-	set(CONAN_TYPE_ARG "--type=${CONAN_TYPE}")
-    endif()
-
-    if(DEFINED CONAN_ARGS)
-	set(CONAN_ARGS_ARGS "--args=\"${CONAN_ARGS}\"")
-    endif()
-
-    if(DEFINED CONAN_SOURCE)
-	set(CONAN_SOURCE_ARGS "--source-folder=${CONAN_SOURCE}")
-    endif()
-
-    if(DEFINED CONAN_TARGET)
-	set(CONAN_TARGET_ARGS "--target-folder=${CONAN_TARGET}")
-    endif()
-
-    set (CONAN_CONFIG_INSTALL_ARGS 	${CONAN_VERIFY_SSL_ARG}
-					${CONAN_TYPE_ARG}
-					${CONAN_ARGS_ARGS}
-					${CONAN_SOURCE_ARGS}
-					${CONAN_TARGET_ARGS})
-
-    message(STATUS "Conan: Installing config from ${CONAN_ITEM}")
-	execute_process(COMMAND ${CONAN_CMD} config install ${CONAN_ITEM} ${CONAN_CONFIG_INSTALL_ARGS}
-                  RESULT_VARIABLE return_code)
-  if(NOT "${return_code}" STREQUAL "0")
-    message(FATAL_ERROR "Conan config failed='${return_code}'")
-  endif()
-endmacro()
\ No newline at end of file
diff --git a/installer/external/CMakeLists.txt b/installer/external/CMakeLists.txt
deleted file mode 100644
index bc662f70..00000000
--- a/installer/external/CMakeLists.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-include(FetchContent)
-
-set(CONFIG_PATH "${CMAKE_SOURCE_DIR}/config.yml")
-set(CONFIG_PARSER_PATH "${CMAKE_SOURCE_DIR}/scripts/parse_config.py")
-
-message("CONFIG_PATH : ${CONFIG_PATH}")
-message("CONFIG_PARSER_PATH : ${CONFIG_PARSER_PATH}")
-
-set(THIRPARTY_NOTICE_FILE "${CMAKE_BINARY_DIR}/license/thirdparty_notice.txt")
-file(WRITE ${THIRPARTY_NOTICE_FILE} "\n--------\n")
-message(STATUS "THIRPARTY_NOTICE_FILE ${THIRPARTY_NOTICE_FILE}")
-
-# Find a Python interpreter
-find_package(Python REQUIRED)
-
-# Print the path of the found Python interpreter
-message(STATUS "Using Python: ${Python_EXECUTABLE}")
-
-add_subdirectory(ion-kit)
-add_subdirectory(opencv)
-add_subdirectory(aravis)
-add_subdirectory(pygobject)
-add_subdirectory(gendc_separator)
-
diff --git a/installer/external/aravis/CMakeLists.txt b/installer/external/aravis/CMakeLists.txt
deleted file mode 100644
index 6c8b503d..00000000
--- a/installer/external/aravis/CMakeLists.txt
+++ /dev/null
@@ -1,186 +0,0 @@
-include(ExternalProject)
-
-# Define variables
-set(ARAVIS_NAME "aravis")
-set(ARAVIS_ACTION "download") # You can set this to a specific action or leave it empty
-
-# Call the Python script and capture its output
-execute_process(
-    COMMAND ${Python_EXECUTABLE} ${CONFIG_PARSER_PATH} --name ${ARAVIS_NAME} --action ${ARAVIS_ACTION} --config-path ${CONFIG_PATH}
-    OUTPUT_VARIABLE OUTPUT_VALUE
-    RESULTS_VARIABLE  RESULT_CODE
-    ERROR_VARIABLE error
-)
-
-
-if(RESULT_CODE)
-    message(FATAL_ERROR "Error while parsing config: ${OUTPUT_VALUE}")
-endif()
-
-#Split the output into a list
-string(REPLACE "\n" ";" OUTPUT_LIST ${OUTPUT_VALUE})
-
-# Set the variables
-list(GET OUTPUT_LIST 0 ARAVIS_NAME)
-list(GET OUTPUT_LIST 3 ARAVIS_ACTION)
-list(GET OUTPUT_LIST 7 ARAVIS_VERSION)
-
-
-# Print to verify
-message("ARAVIS_NAME  ${ARAVIS_NAME}")
-message("ARAVIS_VERSION: ${ARAVIS_VERSION}")
-
-message("ARAVIS_ACTION : ${ARAVIS_ACTION}")
-
-set(ARAVIS_OS_FILE Aravis-${ARAVIS_VERSION})
-set(ARAVIS_DIR ${CMAKE_BINARY_DIR}/external/aravis/src/aravis)
-
-if(ARAVIS_ACTION STREQUAL "build")
-
-    list(GET OUTPUT_LIST 6 ARAVIS_GIT_REPO)
-    message("ARAVIS_GIT_REPO: ${ARAVIS_GIT_REPO}")
-    message(FATAL_ERROR "Option Unimplemented")
-
-elseif(ARAVIS_ACTION STREQUAL "download")
-    list(GET OUTPUT_LIST 4 ARAVIS_PKG_URL)
-    list(GET OUTPUT_LIST 5 ARAVIS_PKG_SHA)
-    message("ARAVIS_PKG_URL: ${ARAVIS_PKG_URL}")
-    message("ARAVIS_PKG_SHA : ${ARAVIS_PKG_SHA}")
-    # # Add aravis external project
-    ExternalProject_Add(
-        aravis_external
-        PREFIX ${CMAKE_BINARY_DIR}/external/aravis
-        URL ${ARAVIS_PKG_URL}
-        URL_HASH SHA256=${ARAVIS_PKG_SHA}  # Use SHA-256 hash
-        DOWNLOAD_DIR ${CMAKE_BINARY_DIR}/external/aravis/downloads  # Specify a downloads directory
-        SOURCE_DIR ${ARAVIS_DIR}
-        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-        CONFIGURE_COMMAND ""  # No configure step needed
-        BUILD_COMMAND ""  # No build step needed
-        INSTALL_COMMAND  ""
-        # COMMAND powershell -Command "Expand-Archive -Path '<DOWNLOAD_DIR>/${ARAVIS_OS_FILE}.zip' -DestinationPath '${CMAKE_SOURCE_DIR}/external/aravis' -Force"
-        BUILD_IN_SOURCE FALSE
-        BUILD_ALWAYS FALSE  # Adjust this according to your needs
-        )
-elseif(ARAVIS_ACTION STREQUAL "use_existing")
-
-    list(GET OUTPUT_LIST 1 ARAVIS_SOURCE)
-    list(GET OUTPUT_LIST 2 ARAVIS_INSTALL)
-    message("ARAVIS_SOURCE : ${ARAVIS_SOURCE}")
-    message("ARAVIS_INSTALL: ${ARAVIS_INSTALL}")
-    message(FATAL_ERROR "Option Unimplemented")
-else()
-    message(FATAL_ERROR "Incorrect action option. Valid values are build, download and use_existing")
-endif()
-
-#-----------------------------------------------------------------------------------------------------------
-
-
-# Define variables
-set(ARAVIS_DEP_NAME "aravis_dep")
-set(ARAVIS_DEP_ACTION "download") # You can set this to a specific action or leave it empty
-
-# Call the Python script and capture its output
-execute_process(
-    COMMAND ${Python_EXECUTABLE} ${CONFIG_PARSER_PATH} --name ${ARAVIS_DEP_NAME} --action ${ARAVIS_DEP_ACTION} --config-path ${CONFIG_PATH}
-    OUTPUT_VARIABLE OUTPUT_VALUE
-    RESULTS_VARIABLE  RESULT_CODE
-    ERROR_VARIABLE error
-)
-
-
-if(RESULT_CODE)
-    message(FATAL_ERROR "Error while parsing config: ${OUTPUT_VALUE}")
-endif()
-
-#Split the output into a list
-string(REPLACE "\n" ";" OUTPUT_LIST ${OUTPUT_VALUE})
-
-# Set the variables
-list(GET OUTPUT_LIST 0 ARAVIS_DEP_NAME)
-list(GET OUTPUT_LIST 3 ARAVIS_DEP_ACTION)
-list(GET OUTPUT_LIST 7 ARAVIS_DEP_VERSION)
-
-# Print to verify
-message("ARAVIS_DEP_NAME  ${ARAVIS_DEP_NAME}")
-message("ARAVIS_DEP_VERSION: ${ARAVIS_DEP_VERSION}")
-
-message("ARAVIS_DEP_ACTION : ${ARAVIS_DEP_ACTION}")
-
-set(ARAVIS_DEP_OS_FILE Aravis-${ARAVIS_DEP_VERSION})
-set(ARAVIS_DEP_PREFIX ${CMAKE_BINARY_DIR}/external/${ARAVIS_DEP_NAME})
-set(ARAVIS_DEP_DIR ${ARAVIS_DEP_PREFIX}/src/${ARAVIS_DEP_NAME})
-
-if(ARAVIS_DEP_ACTION STREQUAL "build")
-
-    list(GET OUTPUT_LIST 6 ARAVIS_DEP_GIT_REPO)
-    message("ARAVIS_DEP_GIT_REPO: ${ARAVIS_DEP_GIT_REPO}")
-    message(FATAL_ERROR "Option Unimplemented")
-
-elseif(ARAVIS_DEP_ACTION STREQUAL "download")
-    list(GET OUTPUT_LIST 4 ARAVIS_DEP_PKG_URL)
-    list(GET OUTPUT_LIST 5 ARAVIS_DEP_PKG_SHA)
-    message("ARAVIS_DEP_PKG_URL: ${ARAVIS_DEP_PKG_URL}")
-    message("ARAVIS_DEP_PKG_SHA : ${ARAVIS_DEP_PKG_SHA}")
-    # # Add aravis external project
-    ExternalProject_Add(
-        aravis_dep_external
-        PREFIX ${ARAVIS_DEP_PREFIX}
-        URL ${ARAVIS_DEP_PKG_URL}
-        URL_HASH SHA256=${ARAVIS_DEP_PKG_SHA}  # Use SHA-256 hash
-        DOWNLOAD_DIR ${ARAVIS_DEP_PREFIX}/downloads  # Specify a downloads directory
-        SOURCE_DIR ${ARAVIS_DEP_DIR}
-        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-        CONFIGURE_COMMAND ""  # No configure step needed
-        BUILD_COMMAND ""  # No build step needed
-        INSTALL_COMMAND  ""
-        # COMMAND powershell -Command "Expand-Archive -Path '<DOWNLOAD_DIR>/${ARAVIS_DEP_OS_FILE}.zip' -DestinationPath '${CMAKE_SOURCE_DIR}/external/aravis' -Force"
-        BUILD_IN_SOURCE FALSE
-        BUILD_ALWAYS FALSE  # Adjust this according to your needs
-        )
-elseif(ARAVIS_DEP_ACTION STREQUAL "use_existing")
-
-    list(GET OUTPUT_LIST 1 ARAVIS_DEP_SOURCE)
-    list(GET OUTPUT_LIST 2 ARAVIS_DEP_INSTALL)
-    message("ARAVIS_DEP_SOURCE : ${ARAVIS_DEP_SOURCE}")
-    message("ARAVIS_DEP_INSTALL: ${ARAVIS_DEP_INSTALL}")
-    message(FATAL_ERROR "Option Unimplemented")
-else()
-    message(FATAL_ERROR "Incorrect action option. Valid values are build, download and use_existing")
-endif()
-
-# Install aravis library, binaries, includes, and shared files
-# install(DIRECTORY ${CMAKE_SOURCE_DIR}/external/aravis/ DESTINATION install)
-install(DIRECTORY ${ARAVIS_DIR}/include/ DESTINATION include)
-install(DIRECTORY ${ARAVIS_DIR}/bin/ DESTINATION bin)
-install(DIRECTORY ${ARAVIS_DIR}/share/ DESTINATION share)
-install(DIRECTORY ${ARAVIS_DIR}/lib/ DESTINATION lib)
-# install(DIRECTORY ${ARAVIS_DIR}/license/ DESTINATION license)
-
-# Specify the aravis library and include directories
-add_library(aravis INTERFACE)
-add_dependencies(aravis aravis_external aravis_dependencies)
-target_include_directories(aravis INTERFACE ${ARAVIS_DIR}/include ${ARAVIS_DEP_DIR}/include)
-
-# Install aravis library, binaries, includes, and shared files
-install(DIRECTORY ${ARAVIS_DEP_DIR}/include/ DESTINATION include)
-install(DIRECTORY ${ARAVIS_DEP_DIR}/bin/ DESTINATION bin)
-install(DIRECTORY ${ARAVIS_DEP_DIR}/lib/ DESTINATION lib)
-
-file(GLOB_RECURSE license_files ${ARAVIS_DIR}/license/COPYING ${ARAVIS_DEP_DIR}/license/*.txt)
-message(VERBOSE "ARAVIS Liscence file found: ${license_files}")
-
-if(EXISTS ${THIRPARTY_NOTICE_FILE})
-    # Copy and concatenate license files
-    file(APPEND ${THIRPARTY_NOTICE_FILE} "${ARAVIS_NAME}\n--------\n")
-
-    foreach(license ${license_files})
-        message(STATUS "Copying ${license} to ${THIRPARTY_NOTICE_FILE}")
-        file(READ ${license} license_content)
-        file(APPEND ${THIRPARTY_NOTICE_FILE} "${license_content}\n--------\n")
-    endforeach()
-else()
-    message(FATAL_ERROR "Source file '${THIRPARTY_NOTICE_FILE}' does not exist.")
-endif()
-
-    
diff --git a/installer/external/gendc_separator/CMakeLists.txt b/installer/external/gendc_separator/CMakeLists.txt
deleted file mode 100644
index d3154992..00000000
--- a/installer/external/gendc_separator/CMakeLists.txt
+++ /dev/null
@@ -1,91 +0,0 @@
-include(ExternalProject)
-
-
-# Define variables
-set(GENDC_SEPERATOR_NAME "gendc_separator")
-set(GENDC_SEPERATOR_ACTION "download") # You can set this to a specific action or leave it empty
-
-# Call the Python script and capture its output
-execute_process(
-    COMMAND ${Python_EXECUTABLE} ${CONFIG_PARSER_PATH} --name ${GENDC_SEPERATOR_NAME} --action ${GENDC_SEPERATOR_ACTION} --config-path ${CONFIG_PATH}
-    OUTPUT_VARIABLE OUTPUT_VALUE
-    RESULTS_VARIABLE  RESULT_CODE
-    ERROR_VARIABLE error
-)
-
-
-if(RESULT_CODE)
-    message(FATAL_ERROR "Error while parsing config: ${OUTPUT_VALUE}")
-endif()
-
-#Split the output into a list
-string(REPLACE "\n" ";" OUTPUT_LIST ${OUTPUT_VALUE})
-
-# Set the variables
-list(GET OUTPUT_LIST 0 GENDC_SEPERATOR_NAME)
-list(GET OUTPUT_LIST 3 GENDC_SEPERATOR_ACTION)
-list(GET OUTPUT_LIST 7 GENDC_SEPERATOR_VERSION)
-
-
-# Print to verify
-message("GENDC_SEPERATOR_NAME  ${GENDC_SEPERATOR_NAME}")
-message("GENDC_SEPERATOR_ACTION : ${GENDC_SEPERATOR_ACTION}")
-message("GENDC_SEPERATOR_VERSION: ${GENDC_SEPERATOR_VERSION}")
-
-
-
-set(GENDC_SEPERATOR_OS_FILE gendc_seperator-${GENDC_SEPERATOR_VERSION})
-set(GENDC_SEPERATOR_DIR ${CMAKE_BINARY_DIR}/external/gendc_seperator/src/${GENDC_SEPERATOR_OS_FILE})
-
-if(GENDC_SEPERATOR_ACTION STREQUAL "build")
-
-    list(GET OUTPUT_LIST 1 GENDC_SEPERATOR_SOURCE)
-    list(GET OUTPUT_LIST 2 GENDC_SEPERATOR_INSTALL)
-    list(GET OUTPUT_LIST 6 GENDC_SEPERATOR_GIT_REPO)
-
-    message("GENDC_SEPERATOR_SOURCE : ${GENDC_SEPERATOR_SOURCE}")
-    message("GENDC_SEPERATOR_INSTALL: ${GENDC_SEPERATOR_INSTALL}")
-    message("GENDC_SEPERATOR_PKG_URL: ${GENDC_SEPERATOR_PKG_URL}")
-
-    message(FATAL_ERROR "Option Unimplemented")
-elseif(GENDC_SEPERATOR_ACTION STREQUAL "download")
-    # Add gendc_seperator external project
-    list(GET OUTPUT_LIST 4 GENDC_SEPERATOR_PKG_URL)
-    list(GET OUTPUT_LIST 5 GENDC_SEPERATOR_PKG_SHA)
-    
-    message("GENDC_SEPERATOR_PKG_SHA : ${GENDC_SEPERATOR_PKG_SHA}")
-    message("GENDC_SEPERATOR_GIT_REPO: ${GENDC_SEPERATOR_GIT_REPO}")
-    
-    ExternalProject_Add(
-        gendc_seperator_external
-        PREFIX ${CMAKE_BINARY_DIR}/external/gendc_seperator
-        URL ${GENDC_SEPERATOR_PKG_URL}
-        URL_HASH SHA256=${GENDC_SEPERATOR_PKG_SHA}  # Use SHA-256 hash
-        DOWNLOAD_DIR ${CMAKE_BINARY_DIR}/external/gendc_seperator/downloads  # Specify a downloads directory
-        SOURCE_DIR ${GENDC_SEPERATOR_DIR}
-        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-        CONFIGURE_COMMAND ""  # No configure step needed
-        BUILD_COMMAND ""  # No build step needed
-        INSTALL_COMMAND  ""
-        # COMMAND powershell -Command "Expand-Archive -Path '<DOWNLOAD_DIR>/${GENDC_SEPERATOR_OS_FILE}.zip' -DestinationPath '${CMAKE_SOURCE_DIR}/external/gendc_seperator' -Force"
-        BUILD_IN_SOURCE FALSE
-        BUILD_ALWAYS FALSE  # Adjust this according to your needs
-    )    
-elseif(GENDC_SEPERATOR_ACTION STREQUAL "use_existing")
-    message(FATAL_ERROR "Option Unimplemented")
-else()
-    message(FATAL_ERROR "Incorrect action option. Valid values are build, download and use_existing")
-endif()
-
-# Add gendc_seperator external project
-
-
-# Specify the gendc_seperator library and include directories
-add_library(gendc_seperator INTERFACE)
-add_dependencies(gendc_seperator gendc_seperator_external )
-target_include_directories(gendc_seperator INTERFACE ${GENDC_SEPERATOR_DIR})
-
-# Install gendc_seperator library, binaries, includes, and shared files
-# install(DIRECTORY ${CMAKE_SOURCE_DIR}/external/gendc_seperator/${GENDC_SEPERATOR_OS_FILE}/ DESTINATION install)
-install(DIRECTORY ${GENDC_SEPERATOR_DIR}/ DESTINATION include/${GENDC_SEPERATOR_NAME})
-
diff --git a/installer/external/ion-kit/CMakeLists.txt b/installer/external/ion-kit/CMakeLists.txt
deleted file mode 100644
index 3f2afbdb..00000000
--- a/installer/external/ion-kit/CMakeLists.txt
+++ /dev/null
@@ -1,111 +0,0 @@
-include(ExternalProject)
-
-
-# Define variables
-set(ION_KIT_NAME "ion_kit")
-set(ION_KIT_ACTION "download") # You can set this to a specific action or leave it empty
-
-# Call the Python script and capture its output
-execute_process(
-    COMMAND ${Python_EXECUTABLE} ${CONFIG_PARSER_PATH} --name ${ION_KIT_NAME} --action ${ION_KIT_ACTION} --config-path ${CONFIG_PATH}
-    OUTPUT_VARIABLE OUTPUT_VALUE
-    RESULTS_VARIABLE  RESULT_CODE
-    ERROR_VARIABLE error
-)
-
-
-if(RESULT_CODE)
-    message(FATAL_ERROR "Error while parsing config: ${OUTPUT_VALUE}")
-endif()
-
-#Split the output into a list
-string(REPLACE "\n" ";" OUTPUT_LIST ${OUTPUT_VALUE})
-
-# Set the variables
-list(GET OUTPUT_LIST 0 ION_KIT_NAME)
-list(GET OUTPUT_LIST 3 ION_KIT_ACTION)
-list(GET OUTPUT_LIST 7 ION_KIT_VERSION)
-
-
-# Print to verify
-message("ION_KIT_NAME  ${ION_KIT_NAME}")
-message("ION_KIT_ACTION : ${ION_KIT_ACTION}")
-message("ION_KIT_VERSION: ${ION_KIT_VERSION}")
-
-
-
-set(ION_KIT_OS_FILE ion-kit-${ION_KIT_VERSION})
-set(ION_KIT_DIR ${CMAKE_BINARY_DIR}/external/ion-kit/src/${ION_KIT_OS_FILE})
-
-if(ION_KIT_ACTION STREQUAL "build")
-
-    list(GET OUTPUT_LIST 1 ION_KIT_SOURCE)
-    list(GET OUTPUT_LIST 2 ION_KIT_INSTALL)
-    list(GET OUTPUT_LIST 6 ION_KIT_GIT_REPO)
-
-    message("ION_KIT_SOURCE : ${ION_KIT_SOURCE}")
-    message("ION_KIT_INSTALL: ${ION_KIT_INSTALL}")
-    message("ION_KIT_PKG_URL: ${ION_KIT_PKG_URL}")
-
-    message(FATAL_ERROR "Option Unimplemented")
-elseif(ION_KIT_ACTION STREQUAL "download")
-    # Add ion-kit external project
-    list(GET OUTPUT_LIST 4 ION_KIT_PKG_URL)
-    list(GET OUTPUT_LIST 5 ION_KIT_PKG_SHA)
-    
-    message("ION_KIT_PKG_SHA : ${ION_KIT_PKG_SHA}")
-    message("ION_KIT_GIT_REPO: ${ION_KIT_GIT_REPO}")
-    
-    ExternalProject_Add(
-        ion-kit_external
-        PREFIX ${CMAKE_BINARY_DIR}/external/ion-kit
-        URL ${ION_KIT_PKG_URL}
-        URL_HASH SHA256=${ION_KIT_PKG_SHA}  # Use SHA-256 hash
-        DOWNLOAD_DIR ${CMAKE_BINARY_DIR}/external/ion-kit/downloads  # Specify a downloads directory
-        SOURCE_DIR ${ION_KIT_DIR}
-        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-        CONFIGURE_COMMAND ""  # No configure step needed
-        BUILD_COMMAND ""  # No build step needed
-        INSTALL_COMMAND  ""
-        # COMMAND powershell -Command "Expand-Archive -Path '<DOWNLOAD_DIR>/${ION_KIT_OS_FILE}.zip' -DestinationPath '${CMAKE_SOURCE_DIR}/external/ion-kit' -Force"
-        BUILD_IN_SOURCE FALSE
-        BUILD_ALWAYS FALSE  # Adjust this according to your needs
-    )    
-elseif(ION_KIT_ACTION STREQUAL "use_existing")
-    message(FATAL_ERROR "Option Unimplemented")
-else()
-    message(FATAL_ERROR "Incorrect action option. Valid values are build, download and use_existing")
-endif()
-
-# Add ion-kit external project
-
-
-# Specify the ion-kit library and include directories
-add_library(ion-kit INTERFACE)
-add_dependencies(ion-kit ion-kit_external )
-target_include_directories(ion-kit INTERFACE ${ION_KIT_DIR}/include)
-
-# Install ion-kit library, binaries, includes, and shared files
-# install(DIRECTORY ${CMAKE_SOURCE_DIR}/external/ion-kit/${ION_KIT_OS_FILE}/ DESTINATION install)
-install(DIRECTORY ${ION_KIT_DIR}/bin/ DESTINATION bin)
-install(DIRECTORY ${ION_KIT_DIR}/include/ DESTINATION include)
-#install(DIRECTORY ${ION_KIT_DIR}/share/ DESTINATION share)
-install(DIRECTORY ${ION_KIT_DIR}/lib/ DESTINATION lib)
-
-# Copy and concatenate license files
-file(GLOB_RECURSE license_files ${ION_KIT_DIR}/license/LICENSE ${ION_KIT_DIR}/license/thirdparty_notice.txt)
-
-# installer\external\ion-kit\ion-kit-0.3.1-win64\license\LICENSE
-message(VERBOSE "Ion-kit Liscence file found: ${license_files}")
-
-if(EXISTS ${THIRPARTY_NOTICE_FILE})
-    file(APPEND ${THIRPARTY_NOTICE_FILE} "${ION_KIT_NAME}\n--------\n")
-
-    foreach(license ${license_files})
-        message(STATUS "Copying ${license} to ${THIRPARTY_NOTICE_FILE}")
-        file(READ ${license} license_content)
-        file(APPEND ${THIRPARTY_NOTICE_FILE} "${license_content}\n--------\n")
-    endforeach()
-else()
-    message(FATAL_ERROR "Source file '${THIRPARTY_NOTICE_FILE}' does not exist.")
-endif()
\ No newline at end of file
diff --git a/installer/external/opencv/CMakeLists.txt b/installer/external/opencv/CMakeLists.txt
deleted file mode 100644
index aa8247dd..00000000
--- a/installer/external/opencv/CMakeLists.txt
+++ /dev/null
@@ -1,109 +0,0 @@
-include(ExternalProject)
-
-# Define variables
-set(OPENCV_NAME "opencv")
-set(OPENCV_ACTION "download" CACHE STRING "OpenCv action, Valid options are(download or use_existing)") # You can set this to a specific action or leave it empty
-
-# Call the Python script and capture its output
-execute_process(
-    COMMAND ${Python_EXECUTABLE} ${CONFIG_PARSER_PATH} --name ${OPENCV_NAME} --action ${OPENCV_ACTION} --config-path ${CONFIG_PATH}
-    OUTPUT_VARIABLE OUTPUT_VALUE
-    RESULTS_VARIABLE RESULT_CODE
-    ERROR_VARIABLE error
-)
-
-if(RESULT_CODE)
-    message(FATAL_ERROR "Error while parsing config: ${OUTPUT_VALUE}")
-endif()
-
-# Split the output into a list
-string(REPLACE "\n" ";" OUTPUT_LIST ${OUTPUT_VALUE})
-
-# Set the variables
-list(GET OUTPUT_LIST 0 OPENCV_NAME)
-
-# list(GET OUTPUT_LIST 3 OPENCV_ACTION)
-list(GET OUTPUT_LIST 7 OPENCV_VERSION)
-
-# Print to verify
-message("OPENCV_NAME  ${OPENCV_NAME}")
-message("OPENCV_ACTION : ${OPENCV_ACTION}")
-message("OPENCV_VERSION: ${OPENCV_VERSION}")
-
-set(OPENCV_OS_FILE archive.tar)
-set(OPENCV_DIR ${CMAKE_BINARY_DIR}/external/opencv/src/opencv)
-
-if(OPENCV_ACTION STREQUAL "build")
-    list(GET OUTPUT_LIST 1 OPENCV_SOURCE)
-    list(GET OUTPUT_LIST 2 OPENCV_INSTALL)
-    list(GET OUTPUT_LIST 6 OPENCV_GIT_REPO)
-
-    message("OPENCV_SOURCE : ${OPENCV_SOURCE}")
-    message("OPENCV_INSTALL: ${OPENCV_INSTALL}")
-    message("OPENCV_GIT_REPO: ${OPENCV_GIT_REPO}")
-    message(FATAL_ERROR "Option Unimplemented, Please use use_existing or download")
-elseif(OPENCV_ACTION STREQUAL "download")
-    list(GET OUTPUT_LIST 4 OPENCV_PKG_URL)
-    list(GET OUTPUT_LIST 5 OPENCV_PKG_SHA)
-
-    message("OPENCV_PKG_URL: ${OPENCV_PKG_URL}")
-    message("OPENCV_PKG_SHA : ${OPENCV_PKG_SHA}")
-
-    # # Add aravis external project
-    ExternalProject_Add(
-        opencv_external
-        PREFIX ${CMAKE_BINARY_DIR}/external/opencv
-        URL ${OPENCV_PKG_URL}
-        URL_HASH SHA256=${OPENCV_PKG_SHA} # Use SHA-256 hash
-        DOWNLOAD_DIR ${CMAKE_BINARY_DIR}/external/opencv/downloads # Specify a downloads directory
-        SOURCE_DIR ${OPENCV_DIR}
-        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-        CONFIGURE_COMMAND "" # No configure step needed
-        BUILD_COMMAND "" # No build step needed
-        INSTALL_COMMAND ""
-
-        # COMMAND powershell -Command "Expand-Archive -Path '<DOWNLOAD_DIR>/${OPENCV_OS_FILE}.zip' -DestinationPath '${CMAKE_SOURCE_DIR}/external/opencv' -Force"
-        BUILD_IN_SOURCE FALSE
-        BUILD_ALWAYS FALSE # Adjust this according to your needs
-    )
-
-    # Specify the opencv library and include directories
-    add_library(opencv INTERFACE)
-    add_dependencies(opencv opencv_external opencv_external_linux)
-    target_include_directories(opencv INTERFACE ${OPENCV_DIR}/include)
-
-    # Install opencv library, binaries, includes, and shared files
-    # Copy everything from v24.04.00
-    message("OPENCV_DIR = ${OPENCV_DIR}")
-    install(DIRECTORY ${OPENCV_DIR}/build DESTINATION opencv)
-
-    # # Update thirdparty_notice.txt
-    # Keep copying third party notice after copying everything 
-    file(GLOB_RECURSE license_files
-        ${OPENCV_DIR}/build/LICENSE
-        ${OPENCV_DIR}/build/LICENSE_FFMPEG.txt
-        ${OPENCV_DIR}/build/etc/licenses/*LICENSE* 
-        ${OPENCV_DIR}/build/etc/licenses/*license* 
-        )
-
-    # installer\external\opencv\build\etc\licenses
-    message(VERBOSE "OpenCV Liscence file found: ${license_files}")
-
-    if(EXISTS ${THIRPARTY_NOTICE_FILE})
-        # Copy and concatenate license files
-        file(APPEND ${THIRPARTY_NOTICE_FILE} "${OPENCV_NAME}\n--------\n")
-
-        foreach(license ${license_files})
-            message(STATUS "Copying ${license} to ${THIRPARTY_NOTICE_FILE}")
-            file(READ ${license} license_content)
-            file(APPEND ${THIRPARTY_NOTICE_FILE} "${license_content}\n--------\n")
-        endforeach()
-    else()
-        message(FATAL_ERROR "Source file '${THIRPARTY_NOTICE_FILE}' does not exist.")
-    endif()
-
-elseif(OPENCV_ACTION STREQUAL "use_existing")
-    message(STATUS "Use local Opencv ")
-else()
-    message(FATAL_ERROR "Incorrect action option. Valid values are build, doewnload and use_existing")
-endif()
diff --git a/installer/external/pygobject/CMakeLists.txt b/installer/external/pygobject/CMakeLists.txt
deleted file mode 100644
index 88113d2e..00000000
--- a/installer/external/pygobject/CMakeLists.txt
+++ /dev/null
@@ -1,111 +0,0 @@
-include(ExternalProject)
-
-# Define variables
-set(PYGOBJECT_NAME "pygobject")
-set(PYGOBJECT_ACTION "download") # You can set this to a specific action or leave it empty
-
-# Call the Python script and capture its output
-execute_process(
-    COMMAND ${Python_EXECUTABLE} ${CONFIG_PARSER_PATH} --name ${PYGOBJECT_NAME} --action ${PYGOBJECT_ACTION} --config-path ${CONFIG_PATH}
-    OUTPUT_VARIABLE OUTPUT_VALUE
-    RESULTS_VARIABLE  RESULT_CODE
-    ERROR_VARIABLE error
-)
-
-
-if(RESULT_CODE)
-    message(FATAL_ERROR "Error while parsing config: ${OUTPUT_VALUE}")
-endif()
-
-#Split the output into a list
-string(REPLACE "\n" ";" OUTPUT_LIST ${OUTPUT_VALUE})
-
-# Set the variables
-list(GET OUTPUT_LIST 0 PYGOBJECT_NAME)
-list(GET OUTPUT_LIST 7 PYGOBJECT_VERSION)
-list(GET OUTPUT_LIST 3 PYGOBJECT_ACTION)
-
-
-# Print to verify
-message("PYGOBJECT_NAME  ${PYGOBJECT_NAME}")
-message("PYGOBJECT_VERSION: ${PYGOBJECT_VERSION}")
-message("PYGOBJECT_ACTION : ${PYGOBJECT_ACTION}")
-
-
-set(PYGOBJECT_OS_FILE pygobject-${PYGOBJECT_VERSION})
-set(PYGOBJECT_DIR ${CMAKE_BINARY_DIR}/external/pygobject/src/pygobject)
-
-if(PYGOBJECT_ACTION STREQUAL "build")
-    list(GET OUTPUT_LIST 1 PYGOBJECT_SOURCE)
-    list(GET OUTPUT_LIST 2 PYGOBJECT_INSTALL)
-    list(GET OUTPUT_LIST 6 PYGOBJECT_GIT_REPO)
-    message("PYGOBJECT_SOURCE : ${PYGOBJECT_SOURCE}")
-    message("PYGOBJECT_INSTALL: ${PYGOBJECT_INSTALL}")
-    message("PYGOBJECT_GIT_REPO: ${PYGOBJECT_GIT_REPO}")
-    message(FATAL_ERROR "Option Unimplemented")
-elseif(PYGOBJECT_ACTION STREQUAL "download")
-    # # Add aravis external project
-    
-    list(GET OUTPUT_LIST 4 PYGOBJECT_PKG_URL)
-    list(GET OUTPUT_LIST 5 PYGOBJECT_PKG_SHA)
-
-    message("PYGOBJECT_PKG_URL: ${PYGOBJECT_PKG_URL}")
-    message("PYGOBJECT_PKG_SHA : ${PYGOBJECT_PKG_SHA}")
-    ExternalProject_Add(
-        pygobject_external
-        PREFIX ${CMAKE_BINARY_DIR}/external/pygobject
-        URL ${PYGOBJECT_PKG_URL}
-        URL_HASH SHA256=${PYGOBJECT_PKG_SHA}  # Use SHA-256 hash
-        DOWNLOAD_DIR ${CMAKE_BINARY_DIR}/external/pygobject/downloads  # Specify a downloads directory
-        SOURCE_DIR ${PYGOBJECT_DIR}
-        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-        CONFIGURE_COMMAND ""  # No configure step needed
-        BUILD_COMMAND ""  # No build step needed
-        INSTALL_COMMAND  ""
-        # COMMAND powershell -Command "Expand-Archive -Path '<DOWNLOAD_DIR>/${PYGOBJECT_OS_FILE}.zip' -DestinationPath '${CMAKE_SOURCE_DIR}/external/pygobject' -Force"
-        BUILD_IN_SOURCE FALSE
-        BUILD_ALWAYS FALSE  # Adjust this according to your needs
-    )  
-    # Add pygobject external project
-    
-elseif(PYGOBJECT_ACTION STREQUAL "use_existing")
-    message(FATAL_ERROR "Option Unimplemented")
-else()
-    message(FATAL_ERROR "Incorrect action option. Valid values are build, download and use_existing")
-endif()
-
-# Specify the pygobject library and include directories
-add_library(pygobject INTERFACE)
-add_dependencies(pygobject pygobject_external)
-target_include_directories(pygobject INTERFACE ${PYGOBJECT_DIR}/include)
-
-# Install pygobject library, binaries, includes, and shared files
-# install(DIRECTORY ${CMAKE_SOURCE_DIR}/external/pygobject/${PYGOBJECT_OS_FILE}/ DESTINATION install)
-install(DIRECTORY ${PYGOBJECT_DIR}/include/ DESTINATION include)
-install(DIRECTORY ${PYGOBJECT_DIR}/bin/ DESTINATION bin)
-install(DIRECTORY ${PYGOBJECT_DIR}/share/ DESTINATION share)
-install(DIRECTORY ${PYGOBJECT_DIR}/lib/ DESTINATION lib)
-
-# install(DIRECTORY ${PYGOBJECT_DIR}/license/ DESTINATION license)
-file(GLOB_RECURSE license_files ${PYGOBJECT_DIR}/license/COPYING)
-
-# installer\external\pygobject\pygobject-0.3.1-win64\license\LICENSE
-message(VERBOSE "Liscence file found: ${license_files}")
-
-if(EXISTS ${THIRPARTY_NOTICE_FILE})
-    # Copy and concatenate license files
-    file(APPEND ${THIRPARTY_NOTICE_FILE} "${PYGOBJECT_NAME}\n--------\n")
-
-    foreach(license ${license_files})
-        message(STATUS "Copying ${license} to ${THIRPARTY_NOTICE_FILE}")
-        file(READ ${license} license_content)
-        file(APPEND ${THIRPARTY_NOTICE_FILE} "${license_content}\n--------\n")
-    endforeach()
-else()
-    message(FATAL_ERROR "Source file '${THIRPARTY_NOTICE_FILE}' does not exist.")
-endif()
-
-
-install(FILES ${THIRPARTY_NOTICE_FILE}
-            DESTINATION license
-        )
diff --git a/installer/scripts/build-Aravis.ps1 b/installer/scripts/build-Aravis.ps1
deleted file mode 100644
index b60a6c4f..00000000
--- a/installer/scripts/build-Aravis.ps1
+++ /dev/null
@@ -1,186 +0,0 @@
-<#
-.SYNOPSIS
-A build script for projects using the Meson build system, with optional Conan integration.
-
-.DESCRIPTION
-The script performs the following steps:
-1. Checks for the existence of the source directory.
-2. Clones the project from a Git repository if the source directory doesn't exist.
-3. Optionally runs Conan scripts for dependencies.
-4. Sets up and builds the project using Meson and Ninja.
-
-.PARAMETER repositoryURL
-URL of the Git repository to clone the project from. Defaults to 'https://github.com/AravisProject/aravis.git'.
-
-.PARAMETER version
-Version tag or branch to checkout after cloning the Git repository. Defaults to '0.8.25'.
-
-.PARAMETER sourceDir
-Path to the source directory.
-
-.PARAMETER pygobjectInstallDir
-Path to the pygobject install directory.
-
-.PARAMETER buildDir
-Path to the build directory. Defaults to '<sourceDir>\build'.
-
-.PARAMETER installDir
-Path where the project will be installed after building. Defaults to '<sourceDir>\install'.
-
-.PARAMETER pkgConfigDir
-Path to the directory for pkg-config files. Defaults to '<sourceDir>\<buildDir>\generators'.
-
-.PARAMETER dependenciesDir
-Path to the directory containing project dependencies. Defaults to '<sourceDir>\<buildDir>\dependencies'.
-
-.PARAMETER nativeINI
-Path to the native.ini file.
-
-.EXAMPLE
-.\build-Pygobject.ps1 -sourceDir "C:\path\to\source"
-
-Builds the project located in 'C:\path\to\source' using the default parameters for other options.
-
-.NOTES
-Make sure to have Git, Meson, and Ninja installed and available in the system PATH.
-#>
-param (
-    [Parameter(Mandatory)]
-    [string]$sourceDir=(Get-Location).Path,
-
-    [Parameter(Mandatory=$true)]
-    [string]$pygobjectInstallDir,
-
-    [Parameter(Mandatory=$false)]
-    [string]$repositoryURL="https://github.com/AravisProject/aravis.git",
-
-    [Parameter(Mandatory=$false)]
-    [string]$version=" 0.8.25",
-
-    [Parameter(Mandatory=$false)]
-    [string]$nativeINI = "$sourceDir\aravis_native.ini",
-
-    [Parameter(Mandatory=$false)]
-    [string]$buildDir = "$sourceDir\build",
-
-    [Parameter(Mandatory=$false)]
-    [string]$installDir = "$sourceDir\install",
-
-    [Parameter(Mandatory=$false)]
-    [string]$pkgConfigDir="$buildDir\generators",
-
-    [Parameter(Mandatory=$false)]
-    [string]$dependenciesDir ="$buildDir\dependencies"
-)
-
-# Set the build directory
-$currentDir = (Get-Location).Path
-Write-Output "currentDir $currentDir"
-Write-Output "sourceDir $sourceDir"
-Write-Output "pygobjectInstallDir $pygobjectInstallDir"
-Write-Output "buildDir $buildDir"
-Write-Output "installDir $installDir"
-Write-Output "pkgConfigDir $pkgConfigDir"
-Write-Output "dependenciesDir $dependenciesDir"
-
-# Check for Git
-if (-not (Get-Command "git" -ErrorAction SilentlyContinue)) {
-    Write-Error "Git is not found. Please ensure it's installed and available in PATH."
-    exit 1
-}
-
-# Check if sourceDir exists. If not, clone the repository
-if (-not (Test-Path $sourceDir)) {
-    git clone $repositoryURL $sourceDir
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Failed to clone repository from $repositoryURL."
-        exit 1
-    }
-    Set-Location $sourceDir
-    git checkout $version
-}
-# Configure environment variables for pkg-config and dependencies if provided
-# if (Test-Path "$pkgConfigDir\activate.ps1") {
-    # . $pkgConfigDir\activate.ps1
-    # . $pkgConfigDir\activate_build.ps1
-    # . $pkgConfigDir\activate_run.ps1
-    # $env:PKG_CONFIG_PATH = "$pygobjectInstallDir\lib\pkgconfig;$pkgConfigDir;$env:PKG_CONFIG_PATH"
-# }
-if (Test-Path $pkgConfigDir) {
-    . $pkgConfigDir\conanbuild.ps1
-    . $pkgConfigDir\conanrun.ps1
-    $env:PKG_CONFIG_PATH = "$pygobjectInstallDir\lib\pkgconfig;$pkgConfigDir;$env:PKG_CONFIG_PATH"
-}
-
-if (Test-Path $dependenciesDir) {
-    $env:LD_LIBRARY_PATH = $dependenciesDir
-    $env:PATH = "$env:PATH;$dependenciesDir\bin;$pygobjectInstallDir\bin"
-}
-# Check if Meson and Ninja are available
-if (-not (Get-Command "meson" -ErrorAction SilentlyContinue)) {
-    Write-Error "Meson is not found. Please ensure it's installed and available in PATH."
-    exit 1
-}
-
-if (-not (Get-Command "ninja" -ErrorAction SilentlyContinue)) {
-    Write-Error "Ninja is not found. Please ensure it's installed and available in PATH."
-    exit 1
-}
-
-if (Test-Path $nativeINI) {
-    $content = Get-Content -Path $nativeINI -Raw
-    $content = $content -replace '@BUILD_ROOT@', $buildDir
-    $iniFilePath="$buildDir\newNative.ini"
-    Set-Content -Path $iniFilePath -Value $content
-    Write-Output "meson setup $buildDir $sourceDir `
-                --prefix=$installDir `
-                --native-file $iniFilePath" 
-    meson setup $buildDir $sourceDir `
-                --prefix=$installDir `
-                --native-file "$iniFilePath" 
-}
-else {
-    # Setup build directory with Meson
-    Write-Output "meson setup $buildDir $sourceDir `
-                    --prefix=$installDir `
-                    --buildtype release `
-                    -Ddocumentation=disabled `
-                    -Dgst-plugin=disabled `
-                    -Dintrospection=enabled `
-                    -Dusb=enabled `
-                    -Dviewer=disabled `
-                    --pkg-config-path   $pygobjectInstallDir\lib\pkgconfig;$pkgConfigDir "
-
-    meson setup $buildDir $sourceDir `
-                --prefix=$installDir `
-                --buildtype release `
-                -Ddocumentation=disabled `
-                -Dgst-plugin=disabled `
-                -Dintrospection=enabled `
-                -Dusb=enabled `
-                -Dviewer=disabled `
-                --pkg-config-path  "$pygobjectInstallDir\lib\pkgconfig;$pkgConfigDir" 
-}
-
-if ($LASTEXITCODE -ne 0) {
-    Write-Error "Failed to setup build directory with Meson."
-    exit 1
-}
-
-# Change to the build directory
-Set-Location $buildDir
-
-# Compile and install the project with Ninja
-
-meson compile -C . -v
-meson install -C .
-
-Set-Location $currentDir
-
-if ($LASTEXITCODE -ne 0) {
-    Write-Error "Build  failed with Ninja."
-    exit 1
-}
-
-Write-Output "Build and install completed successfully!"
-
diff --git a/installer/scripts/build-Pygobject.ps1 b/installer/scripts/build-Pygobject.ps1
deleted file mode 100644
index e73f05b0..00000000
--- a/installer/scripts/build-Pygobject.ps1
+++ /dev/null
@@ -1,168 +0,0 @@
-<#
-.SYNOPSIS
-A build script for projects using the Meson build system, with optional Conan integration.
-
-.DESCRIPTION
-The script performs the following steps:
-1. Checks for the existence of the source directory.
-2. Clones the project from a Git repository if the source directory doesn't exist.
-3. Optionally runs Conan scripts for dependencies.
-4. Sets up and builds the project using Meson and Ninja.
-
-.PARAMETER repositoryURL
-URL of the Git repository to clone the project from. Defaults to 'https://gitlab.gnome.org/GNOME/pygobject.git'.
-
-.PARAMETER version
-Version tag or branch to checkout after cloning the Git repository. Defaults to '3.42.2'.
-
-.PARAMETER sourceDir
-Path to the source directory.
-
-.PARAMETER buildDir
-Path to the build directory. Defaults to '<sourceDir>\build'.
-
-.PARAMETER installDir
-Path where the project will be installed after building. Defaults to '<sourceDir>\install'.
-
-.PARAMETER pkgConfigDir
-Path to the directory for pkg-config files. Defaults to '<sourceDir>\<buildDir>\generators'.
-
-.PARAMETER dependenciesDir
-Path to the directory containing project dependencies. Defaults to '<sourceDir>\<buildDir>\dependencies'.
-
-.PARAMETER nativeINI
-Path to the native.ini file.
-
-.EXAMPLE
-.\build-Pygobject.ps1 -sourceDir "C:\path\to\source"
-
-Builds the project located in 'C:\path\to\source' using the default parameters for other options.
-
-.NOTES
-Make sure to have Git, Meson, and Ninja installed and available in the system PATH.
-#>
-param (
-    [Parameter(Mandatory=$true)]
-    [string]$sourceDir,
-
-    [Parameter(Mandatory=$false)]
-    [string]$repositoryURL="https://gitlab.gnome.org/GNOME/pygobject.git",
-
-    [Parameter(Mandatory=$false)]
-    [string]$version=" 3.42.2",
-
-    [Parameter(Mandatory=$false)]
-    [string]$nativeINI,
-
-    [Parameter(Mandatory=$false)]
-    [string]$buildDir = "$sourceDir\build",
-
-    [Parameter(Mandatory=$false)]
-    [string]$installDir = "$sourceDir\install",
-
-    [Parameter(Mandatory=$false)]
-    [string]$pkgConfigDir="$buildDir\generators",
-
-    [Parameter(Mandatory=$false)]
-    [string]$dependenciesDir ="$buildDir\dependencies"
-)
-
-# Set the build directory
-$currentDir = (Get-Location).Path
-Write-Output "currentDir $currentDir"
-Write-Output "sourceDir $sourceDir"
-Write-Output "buildDir $buildDir"
-Write-Output "installDir $installDir"
-Write-Output "pkgConfigDir $pkgConfigDir"
-Write-Output "dependenciesDir $dependenciesDir"
-
-# Check for Git
-if (-not (Get-Command "git" -ErrorAction SilentlyContinue)) {
-    Write-Error "Git is not found. Please ensure it's installed and available in PATH."
-    exit 1
-}
-
-# Check if sourceDir exists. If not, clone the repository
-if (-not (Test-Path $sourceDir)) {
-    git clone $repositoryURL $sourceDir
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Failed to clone repository from $repositoryURL."
-        exit 1
-    }
-    Set-Location $sourceDir
-    git checkout $version
-}
-# Configure environment variables for pkg-config and dependencies if provided
-if ($pkgConfigDir) {
-    . $pkgConfigDir\conanbuild.ps1
-    . $pkgConfigDir\conanrun.ps1
-    $env:PKG_CONFIG_PATH = "$pkgConfigDir;$env:PKG_CONFIG_PATH"
-}
-
-if ($dependenciesDir) {
-    $env:LD_LIBRARY_PATH = $dependenciesDir
-    $env:PATH = "$env:PATH;$dependenciesDir\bin"
-}
-# Check if Meson and Ninja are available
-if (-not (Get-Command "meson" -ErrorAction SilentlyContinue)) {
-    Write-Error "Meson is not found. Please ensure it's installed and available in PATH."
-    exit 1
-}
-
-if (-not (Get-Command "ninja" -ErrorAction SilentlyContinue)) {
-    Write-Error "Ninja is not found. Please ensure it's installed and available in PATH."
-    exit 1
-}
-
-if (Test-Path $nativeINI) {
-    $content = Get-Content -Path $nativeINI -Raw
-    $content = $content -replace '@BUILD_ROOT@', $buildDir
-    $iniFilePath="$buildDir\newNative.ini"
-    Set-Content -Path $iniFilePath -Value $content
-
-    Write-Output "meson setup $buildDir $sourceDir `
-                --prefix=$installDir `
-                --native-file $iniFilePath" 
-    meson setup $buildDir $sourceDir `
-                --prefix=$installDir `
-                --native-file "$iniFilePath" 
-}
-else {
-    # Setup build directory with Meson
-    Write-Output "meson setup $buildDir $sourceDir `
-                    --prefix=$installDir `
-                    --buildtype release `
-                    -Dpycairo=disabled `
-                    -Dtests=false `
-                    --pkg-config-path  $pkgConfigDir "
-
-    meson setup $buildDir $sourceDir `
-                --prefix=$installDir `
-                --buildtype release `
-                -Dpycairo=disabled `
-                -Dtests=false `
-                --pkg-config-path  "$pkgConfigDir" 
-}
-
-if ($LASTEXITCODE -ne 0) {
-    Write-Error "Failed to setup build directory with Meson."
-    exit 1
-}
-
-# Change to the build directory
-Set-Location $buildDir
-
-# Compile and install the project with Ninja
-
-meson compile -C . -v
-meson install -C .
-
-Set-Location $currentDir
-
-if ($LASTEXITCODE -ne 0) {
-    Write-Error "Build  failed with Ninja."
-    exit 1
-}
-
-Write-Output "Build and install completed successfully!"
-
diff --git a/installer/scripts/conanfile.py b/installer/scripts/conanfile.py
deleted file mode 100644
index 70d4862a..00000000
--- a/installer/scripts/conanfile.py
+++ /dev/null
@@ -1,151 +0,0 @@
-import os
-
-from conan import ConanFile
-from conan.tools.build import check_min_cppstd
-from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
-from conan.tools.files import copy, get
-from conan.tools.meson import MesonToolchain
-required_conan_version = ">=2.0.0"
-
-
-class SensingDevInstallerConan(ConanFile): 
-    settings = "os", "arch", "compiler", "build_type"
-    options = {
-        "shared": [True, False],
-        "fPIC": [True, False],
-    }
-    default_options = {
-        "shared": False,
-        "fPIC": True,
-    }
-    dependencies_folder = "dependencies"
-
-    generators = "PkgConfigDeps","VirtualBuildEnv", "VirtualRunEnv","AutotoolsDeps","CMakeDeps", "CMakeToolchain"
-    
-    all_refs = {
-        "glib/2.76.3",
-        "libxml2/2.11.4",
-        "gstreamer/1.22.3",
-        "zlib/1.2.13",
-        "libusb/1.0.26",
-        "libffi/3.4.4",
-        "libiconv/1.17"
-    }
-
-    def config_options(self):
-        if self.settings.os == "Windows":
-            del self.options.fPIC
-
-    def configure(self):
-        if self.options.shared:
-            self.options.rm_safe("fPIC")
-        self.options["glib*"].shared=True
-        self.settings.rm_safe("compiler.libcxx")
-        self.settings.rm_safe("compiler.cppstd")
-
-    def layout(self):
-        cmake_layout(self, src_folder="src")
-
-    def validate(self):
-        if self.settings.compiler.get_safe("cppstd"):
-            check_min_cppstd(self, 17)
-
-    def source(self):
-        # get(self, **self.conan_data["sources"][self.version], strip_root=True)
-        pass
-
-    def build_requirements(self):
-        self.tool_requires("meson/1.2.3")  
-        self.tool_requires("winflexbison/2.5.24")  
-        self.tool_requires("m4/1.4.19")  
-        self.tool_requires("pkgconf/1.9.3")
-        self.tool_requires("pcre2/10.42")
-
-    def requirements(self):
-        for r in self.all_refs:            
-            self.requires(r)
-            
-        # self.requires("libxml2/2.11.4")
-        # self.requires("gstreamer/1.22.3")
-        # self.requires("zlib/1.2.13")
-        # self.requires("libusb/1.0.26")
-        # self.requires("libffi/3.4.4")  
-        # self.requires("libiconv/1.17")  
-        #self.requires("libgettext/0.21")  
-
-    def generate(self):
-        self.import_dependencies()
-
-    def build(self):
-        self.import_dependencies()
-
-    def package(self):
-        copy(self, "LICENSE.md",
-             dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
-        copy(self, "*.h",
-             dst=os.path.join(self.package_folder, "include"),
-             src=os.path.join(self.source_folder, "include"))
-        for pattern in ["*.a", "*.so*", "*.dylib", "*.lib"]:
-            copy(self, pattern,
-                 dst=os.path.join(self.package_folder, "lib"),
-                 src=self.build_folder,
-                 keep_path=False)
-        for pattern in ["*.exe", "*.dll"]:
-            copy(self, pattern,
-             dst=os.path.join(self.package_folder, "bin"),
-             src=self.build_folder,
-             keep_path=False)
-
-    def import_dependencies(self):
-        dependency_folder = os.path.join(self.build_folder, self.dependencies_folder )       
-        self.output.warning(f"dependency_folder: {dependency_folder}")
-
-        self.buildenv.append_path(name="PKG_CONFIG_PATH", value=dependency_folder)
-        self.runenv.append_path(name="PKG_CONFIG_PATH", value=dependency_folder)
-
-        # dependency_folder = self.sensing_dev_install_dir
-        # self.output.info(f"Value of SENSING_DEV_INSTALL: {self.sensing_dev_install_dir}")
-        try:
-            if dependency_folder is not None:
-                self.output.info(f"Value of dependency_folder: {dependency_folder}")
-                if not os.path.exists(dependency_folder):
-                    os.makedirs(dependency_folder)
-            else:
-                self.output.error("dependency_folder is not set.")    
-
-            include_install_dir = os.path.join(dependency_folder,"include")
-            lib_install_dir = os.path.join(dependency_folder,"lib")
-            bin_install_dir = os.path.join(dependency_folder,"bin")   
-            license_install_dir = os.path.join(dependency_folder,"license")   
-            
-            valid_dep = [d for d in self.dependencies.values() if d.ref.__str__() in self.all_refs]
-            self.output.info(f"valid_dep Dependency List: {valid_dep}")
-            for d in valid_dep:
-                self.output.info(f"Copying Dependency : {d}")
-                info = d.cpp_info
-
-                # Copy dependency bin
-                # bin, *.dll -> ./dependencies/bin
-                # bin, *.exe -> ./dependencies/bin
-                for lib in info.bindirs:
-                    copy(self, pattern="*.dll",src=lib, dst=bin_install_dir) 
-                    copy(self, pattern="*.exe",src=lib, dst=bin_install_dir) 
-                    # full_src_path = os.path.join(os.path.basename(lib),"license")
-                    # copy(self, pattern="*",src=full_src_path, dst=license_install_dir) 
-
-                # Copy dependency libs
-                # lib, *.lib -> ./dependencies/lib
-                # lib, *.h -> ./dependencies/include 
-                for lib in info.libdirs:
-                    copy(self, pattern="*.lib",src=lib, dst=lib_install_dir)
-                    copy(self, pattern="*.h",src=lib, dst=include_install_dir)
-
-                # Copy dependency include
-                # include, *.h -> ./dependencies/include               
-                for dir in info.includedirs:
-                    copy(self, pattern="*.h",src=dir, dst=include_install_dir)   
-                               
-                self.output.info(f"d.license() Dependency List: {d.license}")
-                         
-        except Exception as e:
-                self.output.error(f"An error occurred: {e}")
diff --git a/installer/scripts/parse_config.py b/installer/scripts/parse_config.py
deleted file mode 100644
index 7a5d3a6c..00000000
--- a/installer/scripts/parse_config.py
+++ /dev/null
@@ -1,46 +0,0 @@
-# parse_config.py
-import yaml
-import argparse
-
-VALID_ACTIONS = ['build', 'download', 'use_existing']
-
-def parse_arguments():
-    parser = argparse.ArgumentParser(description="Parse a YAML config to get library details.")
-    
-    # Define the command-line options
-    parser.add_argument("--name", required=True, help="Name of the library in the config.")
-    parser.add_argument("--action", default=None,choices=VALID_ACTIONS, help="Desired action. If not provided, it will default to the action specified in the config.")
-    parser.add_argument("--config-path", required=True, help="Path to the YAML configuration file.")
-    
-    return parser.parse_args()
-
-def main():
-    args = parse_arguments()
-    library_name = args.name
-    desired_action = args.action
-    config_path = args.config_path
-
-    with open(config_path, 'r') as file:
-        # print(f"file : {file}")
-        config = yaml.safe_load(file)
-        
-        if library_name not in config['libraries']:
-            print(f"No library named {library_name} found in {config_path}")
-            return
-        library = config['libraries'][library_name]
-
-        # If the action is not provided via command line, fetch it from the config
-        if  desired_action:
-            library["action"] = desired_action
-        
-        print(library.get("name"))
-        print(library.get("src_path"))
-        print(library.get("install_path"))
-        print(library.get("action"))
-        print(library.get("pkg_url"))
-        print(library.get("pkg_sha"))
-        print(library.get("git_repo"))
-        print(library.get("version"))
-        
-if __name__ == "__main__":
-    main()