Files
hfb_sys/deploy/ocr/vendor/lw.PPOCR.C/CMakeLists.txt
T

3088 lines
143 KiB
CMake

cmake_minimum_required(VERSION 3.20)
project(lw.PPOCR.C VERSION 1.2.1 LANGUAGES C)
option(LW_BUILD_HTTP_DEMO
"Build the cross-platform cpp-httplib HTTP OCR Demo" ON)
option(LW_BUILD_CSHARP_DEMOS
"Build the .NET Framework 3.5 WinForms Demo on Windows" OFF)
option(LW_RUNTIME_ONLY
"Build only the dependency-free native runtime for an embedding target" OFF)
option(LW_DEPLOY_ONNX_MODELS
"Deploy official ONNX assets in Web/Node packages (LWM remains supported)" ON)
option(LW_WASM_SIMD128
"Enable portable WebAssembly SIMD128 for the standalone OCR HTML" ON)
option(LW_WASM_COMPILED_REC
"Experimentally run WASM REC on the compiled physical backend" OFF)
option(LW_WASM_FINE_REC_WIDTHS
"Use 64-pixel adaptive REC width buckets in compiled WASM OCR" OFF)
option(LW_NATIVE_FINE_REC_WIDTHS
"Experimentally reduce native compiled REC padding with finer widths (including 480)" OFF)
option(LW_EXPERIMENTAL_REC_FFN_TILING
"Experimental cache-local Pointwise/GELU/Pointwise scheduling (no arithmetic changes)" OFF)
set(LW_REC_FFN_TILE_PIXELS "96" CACHE STRING "Experimental FFN pixel block (12, 48 or 96)")
set_property(CACHE LW_REC_FFN_TILE_PIXELS PROPERTY STRINGS 12 48 96)
if(NOT LW_REC_FFN_TILE_PIXELS MATCHES "^(12|48|96)$")
message(FATAL_ERROR "LW_REC_FFN_TILE_PIXELS must be 12, 48 or 96")
endif()
option(LW_WASM_COMPILED_DET
"Run WASM DET on the compiled NHWC backend when compiled REC is enabled" ON)
option(LW_WASM_REC_SIMD_KERNELS
"Use SIMD128 Dense and Depthwise kernels in experimental WASM compiled REC" ON)
set(LW_WASM_POINTWISE_ROWS "2" CACHE STRING
"WASM SIMD128 pointwise pixel tile; supported values: 2 or 4")
set_property(CACHE LW_WASM_POINTWISE_ROWS PROPERTY STRINGS 2 4)
if(NOT LW_WASM_POINTWISE_ROWS STREQUAL "2" AND
NOT LW_WASM_POINTWISE_ROWS STREQUAL "4")
message(FATAL_ERROR "LW_WASM_POINTWISE_ROWS must be 2 or 4")
endif()
option(LW_WASM_DB_BITMAP_SIMD
"Experimentally use SIMD128 DB thresholding in compiled WASM OCR" OFF)
option(LW_WEB_LEGACY
"Build the Tiny scalar Web compatibility distribution" OFF)
set(LW_WEB_MIN_CHROME_VERSION "70" CACHE STRING
"Minimum Chromium version for the legacy browser distribution")
option(LW_REC_RESIDENT_WIDTHS
"Prewarm all standard REC widths for native performance experiments" OFF)
option(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH
"Use experimental AVX2+FMA Conv1x1 and terminal MatMul paths in native builds" OFF)
option(LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH
"Use the experimental AVX2+FMA Conv1x1 dispatch in native builds" OFF)
option(LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH
"Use the experimental AVX2+FMA terminal MatMul dispatch in native builds" OFF)
option(LW_EXPERIMENTAL_AVX2_FAST_PATH
"Enable compiled AVX2/FMA x64 REC backends for adaptive widths" ON)
option(LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET
"Share the native x64 REC intra-op thread budget across active line workers" ON)
option(LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE
"Use the OpenCV-parity fixed-point DET resize with LUT normalization" ON)
option(LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE
"Use the keep-aspect fixed-point CLS resize with -1 padding" ON)
option(LW_EXPERIMENTAL_PERSISTENT_LINE_POOL
"Reuse a persistent line-worker thread pool across OCR requests" ON)
option(LW_EXPERIMENTAL_PARALLEL_CROP_PHASE
"Rasterize perspective crops as parallel row-band jobs" ON)
option(LW_EXPERIMENTAL_PREPARED_EXECUTION
"Build the experimental session-local prepared execution table" OFF)
option(LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2
"Use the experimental size-descending workspace interval planner" OFF)
option(LW_EXPERIMENTAL_FUSION_MEMORY
"Use the experimental physical lifetime plan for fused GELU" OFF)
option(LW_EXPERIMENTAL_CTC_TILED
"Use the experimental physical plan for greedy CTC output elision" OFF)
option(LW_WASM_REC_LAZY_FALLBACK
"Avoid canonical REC execution allocations until a compiled WASM fallback is needed" OFF)
option(LW_EXPERIMENTAL_STREAMING_CROPS
"Use experimental worker-local streaming crop buffers" OFF)
option(LW_AVX2_FMA_CONV3X3_DISPATCH
"Enable the measured AVX2+FMA Conv3x3 Node 6 dispatch" ON)
option(LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS
"Use experimental AVX2 eight-output blocking for unit-stride Conv3x3" OFF)
set(LW_WASM_HOST_ABI_VERSION "1" CACHE STRING
"WASM Host ABI version embedded in the Web adapter and Node manifest")
set(LW_LWM_FORMAT_VERSION "0.1" CACHE STRING
"LWM model format version recorded in distribution manifests")
option(LW_WEB_PDF
"Embed offline PDF.js support in the standalone OCR HTML" ON)
option(LW_BUILD_WEB_MODEL_VARIANTS
"Build standalone PP-OCRv6 Small and Medium browser SDK/HTML variants" OFF)
set(LW_PRECONVERTED_ASSETS_DIR "" CACHE PATH
"Directory containing preconverted LWM models and PPM fixtures")
set(LW_BUILD_ENVIRONMENT_FILE "" CACHE FILEPATH
"Optional build-environment report installed in the package root")
set(LW_STAGED_PACKAGE_TEST_TIMEOUT 240 CACHE STRING
"Timeout in seconds for the installed-package smoke test")
set(LW_HTTP_TEST_REQUEST_TIMEOUT 30 CACHE STRING
"Timeout in seconds for one HTTP package-test request")
set(LW_HTTP_TEST_PROCESS_TIMEOUT 120 CACHE STRING
"Timeout in seconds for the complete HTTP package-test process")
set(LW_PACKAGE_PLATFORM_OVERRIDE "" CACHE STRING
"Optional explicit platform suffix for the CPack archive name")
if(LW_BUILD_HTTP_DEMO)
enable_language(CXX)
endif()
if(NOT LW_WASM_HOST_ABI_VERSION MATCHES "^[0-9]+$")
message(FATAL_ERROR "LW_WASM_HOST_ABI_VERSION must be a positive integer")
endif()
if(NOT LW_LWM_FORMAT_VERSION MATCHES "^[0-9]+\\.[0-9]+$")
message(FATAL_ERROR "LW_LWM_FORMAT_VERSION must use the form major.minor")
endif()
if(LW_EXPERIMENTAL_FUSION_MEMORY AND NOT LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2)
message(FATAL_ERROR
"LW_EXPERIMENTAL_FUSION_MEMORY requires LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2")
endif()
if(LW_EXPERIMENTAL_CTC_TILED AND NOT LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2)
message(FATAL_ERROR
"LW_EXPERIMENTAL_CTC_TILED requires LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2")
endif()
if(LW_WEB_LEGACY)
if(LW_WASM_SIMD128)
message(FATAL_ERROR
"LW_WEB_LEGACY requires LW_WASM_SIMD128=OFF")
endif()
if(LW_WEB_PDF)
message(FATAL_ERROR
"LW_WEB_LEGACY requires LW_WEB_PDF=OFF")
endif()
if(LW_BUILD_WEB_MODEL_VARIANTS)
message(FATAL_ERROR
"LW_WEB_LEGACY supports PP-OCRv6 Tiny only")
endif()
if(NOT LW_WEB_MIN_CHROME_VERSION MATCHES "^[0-9]+$")
message(FATAL_ERROR
"LW_WEB_MIN_CHROME_VERSION must be an integer")
endif()
endif()
include(CTest)
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
include(CheckCCompilerFlag)
if(NOT LW_RUNTIME_ONLY)
find_package(Python3 3.9 COMPONENTS Interpreter REQUIRED)
endif()
if(NOT EMSCRIPTEN)
find_package(Threads REQUIRED)
endif()
if(NOT LW_RUNTIME_ONLY)
set(LW_PPOCR_C_ANALYSIS_JSON
"${CMAKE_CURRENT_SOURCE_DIR}/docs/ppocrv6-tiny-analysis.json")
set(LW_PPOCR_C_ANALYSIS_MARKDOWN
"${CMAKE_CURRENT_SOURCE_DIR}/docs/SUPPORTED_OPS_V0.md")
set(LW_PPOCR_C_REC_ONNX
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/rec.onnx")
set(LW_PPOCR_C_REC_LWM
"${CMAKE_CURRENT_BINARY_DIR}/models/rec.lwm")
set(LW_PPOCR_C_REC_LWM_METADATA
"${CMAKE_CURRENT_BINARY_DIR}/models/rec-lwm.json")
set(LW_PPOCR_C_CLS_ONNX
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/cls.onnx")
set(LW_PPOCR_C_CLS_LWM
"${CMAKE_CURRENT_BINARY_DIR}/models/cls.lwm")
set(LW_PPOCR_C_CLS_LWM_METADATA
"${CMAKE_CURRENT_BINARY_DIR}/models/cls-lwm.json")
set(LW_PPOCR_C_DET_ONNX
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/det.onnx")
set(LW_PPOCR_C_DET_LWM
"${CMAKE_CURRENT_BINARY_DIR}/models/det.lwm")
set(LW_PPOCR_C_DET_LWM_METADATA
"${CMAKE_CURRENT_BINARY_DIR}/models/det-lwm.json")
if(LW_DEPLOY_ONNX_MODELS)
set(LW_DEPLOY_MODEL_FORMAT onnx)
set(LW_DEPLOY_DET "${LW_PPOCR_C_DET_ONNX}")
set(LW_DEPLOY_CLS "${LW_PPOCR_C_CLS_ONNX}")
set(LW_DEPLOY_REC "${LW_PPOCR_C_REC_ONNX}")
else()
set(LW_DEPLOY_MODEL_FORMAT lwm)
set(LW_DEPLOY_DET "${LW_PPOCR_C_DET_LWM}")
set(LW_DEPLOY_CLS "${LW_PPOCR_C_CLS_LWM}")
set(LW_DEPLOY_REC "${LW_PPOCR_C_REC_LWM}")
endif()
add_custom_target(analyze_models
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/converter/analyze_onnx.py"
--json-output "${LW_PPOCR_C_ANALYSIS_JSON}"
--markdown-output "${LW_PPOCR_C_ANALYSIS_MARKDOWN}"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Analyzing bundled PP-OCRv6 tiny ONNX models"
VERBATIM)
if(LW_PRECONVERTED_ASSETS_DIR)
get_filename_component(LW_PRECONVERTED_ASSETS_DIR
"${LW_PRECONVERTED_ASSETS_DIR}" ABSOLUTE)
foreach(asset IN ITEMS
rec.lwm rec-lwm.json cls.lwm cls-lwm.json det.lwm det-lwm.json
sample-crop.ppm sample.ppm)
if(NOT EXISTS "${LW_PRECONVERTED_ASSETS_DIR}/${asset}")
message(FATAL_ERROR
"LW_PRECONVERTED_ASSETS_DIR is missing required file: ${asset}")
endif()
endforeach()
message(STATUS
"Using preconverted models and fixtures from ${LW_PRECONVERTED_ASSETS_DIR}")
function(lw_copy_preconverted_pair output_a name_a output_b name_b label)
add_custom_command(
OUTPUT "${output_a}" "${output_b}"
COMMAND "${CMAKE_COMMAND}" -E make_directory
"${CMAKE_CURRENT_BINARY_DIR}/models"
COMMAND "${CMAKE_COMMAND}" -E copy_if_different
"${LW_PRECONVERTED_ASSETS_DIR}/${name_a}" "${output_a}"
COMMAND "${CMAKE_COMMAND}" -E copy_if_different
"${LW_PRECONVERTED_ASSETS_DIR}/${name_b}" "${output_b}"
DEPENDS
"${LW_PRECONVERTED_ASSETS_DIR}/${name_a}"
"${LW_PRECONVERTED_ASSETS_DIR}/${name_b}"
COMMENT "Copying preconverted ${label} assets"
VERBATIM)
endfunction()
lw_copy_preconverted_pair(
"${LW_PPOCR_C_REC_LWM}" rec.lwm
"${LW_PPOCR_C_REC_LWM_METADATA}" rec-lwm.json REC)
lw_copy_preconverted_pair(
"${LW_PPOCR_C_CLS_LWM}" cls.lwm
"${LW_PPOCR_C_CLS_LWM_METADATA}" cls-lwm.json CLS)
lw_copy_preconverted_pair(
"${LW_PPOCR_C_DET_LWM}" det.lwm
"${LW_PPOCR_C_DET_LWM_METADATA}" det-lwm.json DET)
else()
add_custom_command(
OUTPUT "${LW_PPOCR_C_REC_LWM}" "${LW_PPOCR_C_REC_LWM_METADATA}"
COMMAND "${Python3_EXECUTABLE}" -m converter.convert_rec
--input "${LW_PPOCR_C_REC_ONNX}"
--output "${LW_PPOCR_C_REC_LWM}"
--metadata-output "${LW_PPOCR_C_REC_LWM_METADATA}"
DEPENDS
"${LW_PPOCR_C_REC_ONNX}"
"${CMAKE_CURRENT_SOURCE_DIR}/converter/convert_rec.py"
"${CMAKE_CURRENT_SOURCE_DIR}/converter/lwm_v0.py"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Converting PP-OCRv6 tiny REC to LWM v0.1"
VERBATIM)
add_custom_command(
OUTPUT "${LW_PPOCR_C_CLS_LWM}" "${LW_PPOCR_C_CLS_LWM_METADATA}"
COMMAND "${Python3_EXECUTABLE}" -m converter.convert_cls
--input "${LW_PPOCR_C_CLS_ONNX}"
--output "${LW_PPOCR_C_CLS_LWM}"
--metadata-output "${LW_PPOCR_C_CLS_LWM_METADATA}"
DEPENDS
"${LW_PPOCR_C_CLS_ONNX}"
"${CMAKE_CURRENT_SOURCE_DIR}/converter/convert_cls.py"
"${CMAKE_CURRENT_SOURCE_DIR}/converter/lwm_v0.py"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Converting PP-OCRv6 tiny CLS to LWM v0.1"
VERBATIM)
add_custom_command(
OUTPUT "${LW_PPOCR_C_DET_LWM}" "${LW_PPOCR_C_DET_LWM_METADATA}"
COMMAND "${Python3_EXECUTABLE}" -m converter.convert_det
--input "${LW_PPOCR_C_DET_ONNX}"
--output "${LW_PPOCR_C_DET_LWM}"
--metadata-output "${LW_PPOCR_C_DET_LWM_METADATA}"
DEPENDS
"${LW_PPOCR_C_DET_ONNX}"
"${CMAKE_CURRENT_SOURCE_DIR}/converter/convert_det.py"
"${CMAKE_CURRENT_SOURCE_DIR}/converter/lwm_v0.py"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Converting PP-OCRv6 tiny DET to LWM v0.1"
VERBATIM)
endif()
add_custom_target(convert_rec_model ALL
DEPENDS "${LW_PPOCR_C_REC_LWM}" "${LW_PPOCR_C_REC_LWM_METADATA}")
add_custom_target(convert_cls_model ALL
DEPENDS "${LW_PPOCR_C_CLS_LWM}" "${LW_PPOCR_C_CLS_LWM_METADATA}")
add_custom_target(convert_det_model ALL
DEPENDS "${LW_PPOCR_C_DET_LWM}" "${LW_PPOCR_C_DET_LWM_METADATA}")
endif()
set(LW_PPOCR_C_SOURCES
src/kernels/packed_conv.c
src/kernels/packed_conv3x3.c
src/kernels/packed_matmul.c
src/kernels/scalar_activation.c
src/kernels/scalar_conv.c
src/kernels/scalar_elementwise.c
src/kernels/scalar_layout.c
src/kernels/scalar_matmul.c
src/kernels/scalar_reduction.c
src/kernels/scalar_softmax.c
src/ppocr/classifier.c
src/ppocr/cls_preprocess.c
src/ppocr/ctc_decode.c
src/ppocr/crop.c
src/ppocr/crop_buffer.c
src/ppocr/db_postprocess.c
src/ppocr/det_preprocess.c
src/ppocr/det_preprocess_fixed.c
src/ppocr/detector.c
src/ppocr/ocr.c
src/ppocr/profile.c
src/ppocr/reading_order.c
src/ppocr/rec_preprocess.c
src/ppocr/recognizer.c
src/runtime/executor.c
src/runtime/cpu_topology.c
src/runtime/execution_plan.c
src/runtime/memory.c
src/runtime/model.c
src/runtime/onnx_import.c
src/runtime/parallel.c
src/runtime/ctc_head_parallel_internal.c
src/runtime/prepared_execution.c
src/runtime/session.c
src/runtime/shape.c
src/runtime/validate.c
src/simd/avx2_binary.c
src/simd/avx2_bitmap.c
src/simd/avx2_conv1x1.c
src/simd/avx2_conv2x2.c
src/simd/avx2_conv3x3.c
src/simd/avx2_conv3x3_eight.c
src/simd/avx2_conv7x7.c
src/simd/avx2_convtranspose2x2.c
src/simd/avx2_depthwise3x3.c
src/simd/avx2_depthwise5x5.c
src/simd/avx2_depthwise9x9.c
src/simd/avx2_erf.c
src/simd/avx2_transpose.c
src/simd/avx2_softmax.c
src/simd/avx2_matmul.c
src/simd/avx2_fma_packed_matmul.c
src/simd/avx2_packed_conv1x1.c
src/simd/avx2_fma_packed_conv1x1.c
src/simd/avx2_fma_packed_conv1x1_8x8.c
src/simd/cpu_features.c
src/simd/lsx_packed_conv1x1.c
src/simd/neon_conv3x3.c
src/simd/neon_convtranspose2x2.c
src/simd/neon_packed_conv1x1.c
src/simd/sse2_binary.c
src/simd/sse2_conv1x1.c
src/simd/sse2_conv2x2.c
src/simd/sse2_conv3x3.c
src/simd/sse2_convtranspose2x2.c
src/simd/sse2_depthwise3x3.c
src/simd/sse2_depthwise5x5.c
src/simd/sse2_matmul.c
src/simd/sse2_packed_conv1x1.c
src/simd/wasm128_erf.c)
set(LW_X64_REC_FAST_ENABLED OFF)
set(LW_WASM_COMPILED_REC_ENABLED OFF)
if(LW_EXPERIMENTAL_AVX2_FAST_PATH AND NOT EMSCRIPTEN AND
(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|amd64|AMD64|x64|X86)$" OR
MSVC_C_ARCHITECTURE_ID MATCHES "^(x64|X86)$"))
set(LW_X64_REC_FAST_ENABLED ON)
endif()
if(EMSCRIPTEN AND LW_WASM_SIMD128 AND LW_WASM_COMPILED_REC)
set(LW_WASM_COMPILED_REC_ENABLED ON)
elseif(EMSCRIPTEN AND LW_WASM_COMPILED_REC)
message(FATAL_ERROR "LW_WASM_COMPILED_REC requires LW_WASM_SIMD128=ON")
endif()
if(LW_WASM_REC_LAZY_FALLBACK AND
(NOT LW_WASM_COMPILED_REC_ENABLED OR LW_EXPERIMENTAL_CTC_TILED))
message(FATAL_ERROR
"LW_WASM_REC_LAZY_FALLBACK requires compiled SIMD128 REC without CTC tiled mode")
endif()
if(LW_WASM_FINE_REC_WIDTHS AND NOT LW_WASM_COMPILED_REC_ENABLED)
message(FATAL_ERROR "LW_WASM_FINE_REC_WIDTHS requires compiled SIMD128 WASM REC")
endif()
if(LW_NATIVE_FINE_REC_WIDTHS AND
(NOT LW_X64_REC_FAST_ENABLED OR NOT CMAKE_SIZEOF_VOID_P EQUAL 8))
message(FATAL_ERROR "LW_NATIVE_FINE_REC_WIDTHS requires compiled native x64 REC")
endif()
if(LW_X64_REC_FAST_ENABLED OR LW_WASM_COMPILED_REC_ENABLED)
list(APPEND LW_PPOCR_C_SOURCES
src/runtime/layout_planner.c
src/runtime/x64_rec_fast_plan.c
src/runtime/x64_rec_fast_executor.c
src/runtime/x64_rec_backend_compile.c
src/runtime/x64_rec_backend_execute.c
src/runtime/x64_rec_backend_arena.c
src/runtime/rec_backend_kernels.c
src/runtime/x64_det_backend_compile.c
src/runtime/x64_det_backend_execute.c
src/runtime/ctc_projection_internal.c
src/runtime/layout_convert_x64.c
src/kernels/nhwc_pack.c
src/kernels/nhwc_depthwise.c
src/simd/avx2_nhwc_pointwise.c
src/simd/avx2_nhwc_depthwise.c
src/simd/avx2_nhwc_support.c
src/simd/avx2_nhwc_dense.c
src/simd/avx2_nhwc_convtranspose.c)
endif()
if(LW_WASM_COMPILED_REC_ENABLED)
list(APPEND LW_PPOCR_C_SOURCES
src/simd/wasm128_nhwc_pointwise.c
src/simd/wasm128_elementwise.c
src/simd/wasm128_matmul.c
src/simd/wasm128_nhwc_convtranspose.c
src/simd/wasm128_packed_matmul.c)
if(LW_WASM_DB_BITMAP_SIMD)
list(APPEND LW_PPOCR_C_SOURCES src/simd/wasm128_bitmap.c)
endif()
endif()
if(MSVC AND MSVC_C_ARCHITECTURE_ID MATCHES "^(x64|X86)$")
set_property(SOURCE src/simd/avx2_binary.c src/simd/avx2_conv1x1.c
src/simd/avx2_conv2x2.c
src/simd/avx2_conv3x3.c src/simd/avx2_conv3x3_eight.c
src/simd/avx2_conv7x7.c
src/simd/avx2_convtranspose2x2.c
src/simd/avx2_depthwise3x3.c
src/simd/avx2_depthwise5x5.c
src/simd/avx2_depthwise9x9.c
src/simd/avx2_erf.c src/simd/avx2_transpose.c src/simd/avx2_matmul.c
src/simd/avx2_fma_packed_matmul.c
src/simd/avx2_packed_conv1x1.c src/simd/avx2_fma_packed_conv1x1.c
src/simd/avx2_fma_packed_conv1x1_8x8.c APPEND PROPERTY
COMPILE_OPTIONS /arch:AVX2 /fp:strict)
set_property(SOURCE src/simd/cpu_features.c APPEND PROPERTY
COMPILE_OPTIONS /arch:AVX)
endif()
string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" LW_SYSTEM_PROCESSOR_LOWER)
# Keep the portable Conv references and their SIMD implementations on the same
# multiply-then-add contract. GCC enables FP contraction by default on AArch64
# and LoongArch, while the intrinsic kernels below deliberately use separate
# multiply and add instructions so their outputs remain byte-identical to the
# established x86 kernels and golden checksums.
set(LW_REPRODUCIBLE_CONV_SOURCES
src/kernels/packed_conv.c
src/kernels/packed_conv3x3.c
src/kernels/scalar_conv.c
src/simd/lsx_packed_conv1x1.c
src/simd/neon_conv3x3.c
src/simd/neon_convtranspose2x2.c
src/simd/neon_packed_conv1x1.c)
if(MSVC AND LW_SYSTEM_PROCESSOR_LOWER MATCHES "^(arm64|aarch64)$")
set_property(SOURCE ${LW_REPRODUCIBLE_CONV_SOURCES} APPEND PROPERTY
COMPILE_OPTIONS /fp:strict)
elseif(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
set_property(SOURCE ${LW_REPRODUCIBLE_CONV_SOURCES} APPEND PROPERTY
COMPILE_OPTIONS -ffp-contract=off)
endif()
if(LW_SYSTEM_PROCESSOR_LOWER MATCHES "^(loongarch64|loong64)$")
check_c_compiler_flag("-mlsx" LW_COMPILER_SUPPORTS_LSX)
if(NOT LW_COMPILER_SUPPORTS_LSX)
message(FATAL_ERROR "The LoongArch compiler must support -mlsx")
endif()
set_property(SOURCE src/simd/lsx_packed_conv1x1.c APPEND PROPERTY
COMPILE_OPTIONS -mlsx -mno-lasx)
endif()
function(lw_configure_runtime_target target)
if(LW_EXPERIMENTAL_REC_FFN_TILING)
target_compile_definitions(${target} PRIVATE LW_EXPERIMENTAL_REC_FFN_TILING=1
LW_REC_FFN_TILE_PIXELS=${LW_REC_FFN_TILE_PIXELS})
endif()
if(LW_NATIVE_FINE_REC_WIDTHS AND LW_X64_REC_FAST_ENABLED)
target_compile_definitions(${target} PRIVATE LW_NATIVE_FINE_REC_WIDTHS=1)
endif()
target_include_directories(${target}
PUBLIC
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
"$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(${target} PUBLIC c_std_11)
if(NOT EMSCRIPTEN)
target_link_libraries(${target} PUBLIC Threads::Threads)
endif()
if(MSVC)
target_compile_options(${target} PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(${target} PRIVATE
-Wall -Wextra -Wpedantic -Werror)
target_link_libraries(${target} PUBLIC m)
endif()
if(EMSCRIPTEN AND LW_WASM_SIMD128)
# Keep the offline single-HTML build single-threaded, but compile its
# scalar/SSE2-compatible kernels to portable WebAssembly SIMD128.
# -msse2 enables Emscripten's compatible <emmintrin.h> surface;
# -msimd128 lowers those intrinsics to portable WASM SIMD instructions.
target_compile_options(${target} PRIVATE -O3 -msimd128 -msse2)
endif()
endfunction()
add_library(lw_ppocr_c STATIC ${LW_PPOCR_C_SOURCES})
set_target_properties(lw_ppocr_c PROPERTIES
EXPORT_NAME static
OUTPUT_NAME lw_ppocr_c_static
POSITION_INDEPENDENT_CODE ON)
lw_configure_runtime_target(lw_ppocr_c)
if(LW_X64_REC_FAST_ENABLED OR LW_WASM_COMPILED_REC_ENABLED)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
if(LW_X64_REC_FAST_ENABLED AND LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET=1)
endif()
if(LW_WASM_COMPILED_REC_ENABLED)
if(LW_WASM_FINE_REC_WIDTHS)
target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_FINE_REC_WIDTHS=1)
endif()
target_compile_definitions(lw_ppocr_c PRIVATE
LW_WASM_POINTWISE_ROWS=${LW_WASM_POINTWISE_ROWS})
endif()
if(LW_WASM_COMPILED_REC_ENABLED AND LW_WASM_REC_SIMD_KERNELS)
target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_REC_SIMD_KERNELS=1)
endif()
if(LW_WASM_COMPILED_REC_ENABLED AND LW_WASM_DB_BITMAP_SIMD)
target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_DB_BITMAP_SIMD=1)
endif()
if(LW_WASM_COMPILED_REC_ENABLED AND LW_WASM_COMPILED_DET AND
LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE)
target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_COMPILED_DET=1)
endif()
if(MSVC)
set_property(SOURCE src/simd/avx2_nhwc_pointwise.c src/simd/avx2_nhwc_dense.c src/simd/avx2_nhwc_depthwise.c src/simd/avx2_nhwc_support.c src/simd/avx2_nhwc_convtranspose.c APPEND PROPERTY
COMPILE_OPTIONS /arch:AVX2 /fp:strict)
endif()
endif()
if(LW_WASM_REC_LAZY_FALLBACK)
target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_REC_LAZY_FALLBACK=1)
endif()
if(LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE=1)
endif()
if(LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE=1)
endif()
if(LW_EXPERIMENTAL_PERSISTENT_LINE_POOL)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_PERSISTENT_LINE_POOL=1)
endif()
if(LW_EXPERIMENTAL_PARALLEL_CROP_PHASE)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_PARALLEL_CROP_PHASE=1)
endif()
if(LW_REC_RESIDENT_WIDTHS AND NOT EMSCRIPTEN)
target_compile_definitions(lw_ppocr_c PRIVATE LW_REC_RESIDENT_WIDTHS=1)
endif()
if((LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH) AND NOT EMSCRIPTEN)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH=1)
endif()
if((LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH) AND NOT EMSCRIPTEN)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH=1)
endif()
if(LW_AVX2_FMA_CONV3X3_DISPATCH AND NOT EMSCRIPTEN)
target_compile_definitions(lw_ppocr_c PRIVATE LW_AVX2_FMA_CONV3X3_DISPATCH=1)
endif()
if(LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS AND NOT EMSCRIPTEN)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS=1)
endif()
if(LW_EXPERIMENTAL_PREPARED_EXECUTION)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_PREPARED_EXECUTION=1)
endif()
if(LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2=1)
endif()
if(LW_EXPERIMENTAL_FUSION_MEMORY)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_FUSION_MEMORY=1)
endif()
if(LW_EXPERIMENTAL_CTC_TILED)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_CTC_TILED=1)
endif()
if(LW_EXPERIMENTAL_STREAMING_CROPS)
target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_STREAMING_CROPS=1)
endif()
if(NOT EMSCRIPTEN AND NOT LW_RUNTIME_ONLY)
add_library(lw_ppocr_c_shared SHARED ${LW_PPOCR_C_SOURCES})
set_target_properties(lw_ppocr_c_shared PROPERTIES
EXPORT_NAME shared
OUTPUT_NAME lw_ppocr_c
VERSION ${PROJECT_VERSION}
SOVERSION ${PROJECT_VERSION_MAJOR}
C_VISIBILITY_PRESET hidden)
target_compile_definitions(lw_ppocr_c_shared
PRIVATE LW_PPOCR_C_BUILD LW_PPOCR_C_SHARED
INTERFACE LW_PPOCR_C_SHARED)
lw_configure_runtime_target(lw_ppocr_c_shared)
if(LW_X64_REC_FAST_ENABLED)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
if(LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET=1)
endif()
if(MSVC)
set_property(SOURCE src/simd/avx2_nhwc_pointwise.c src/simd/avx2_nhwc_dense.c src/simd/avx2_nhwc_depthwise.c src/simd/avx2_nhwc_support.c src/simd/avx2_nhwc_convtranspose.c APPEND PROPERTY
COMPILE_OPTIONS /arch:AVX2 /fp:strict)
endif()
endif()
if(LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE=1)
endif()
if(LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE=1)
endif()
if(LW_EXPERIMENTAL_PERSISTENT_LINE_POOL)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_PERSISTENT_LINE_POOL=1)
endif()
if(LW_EXPERIMENTAL_PARALLEL_CROP_PHASE)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_PARALLEL_CROP_PHASE=1)
endif()
if(LW_REC_RESIDENT_WIDTHS)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_REC_RESIDENT_WIDTHS=1)
endif()
if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH=1)
endif()
if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH=1)
endif()
if(LW_AVX2_FMA_CONV3X3_DISPATCH AND NOT EMSCRIPTEN)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_AVX2_FMA_CONV3X3_DISPATCH=1)
endif()
if(LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS=1)
endif()
if(LW_EXPERIMENTAL_PREPARED_EXECUTION)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_PREPARED_EXECUTION=1)
endif()
if(LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2=1)
endif()
if(LW_EXPERIMENTAL_FUSION_MEMORY)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_FUSION_MEMORY=1)
endif()
if(LW_EXPERIMENTAL_CTC_TILED)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_CTC_TILED=1)
endif()
if(LW_EXPERIMENTAL_STREAMING_CROPS)
target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_STREAMING_CROPS=1)
endif()
endif()
if(LW_RUNTIME_ONLY)
message(STATUS "LW_RUNTIME_ONLY enabled: skipping model conversion, demos, tests, install and packaging")
return()
endif()
if(EMSCRIPTEN)
if(LW_WEB_LEGACY)
find_program(LW_NODE_EXECUTABLE NAMES node nodejs REQUIRED)
set(LW_LEGACY_ESBUILD_ENTRY
"${CMAKE_CURRENT_SOURCE_DIR}/web/node_modules/esbuild/package.json")
if(NOT EXISTS "${LW_LEGACY_ESBUILD_ENTRY}")
message(FATAL_ERROR
"LW_WEB_LEGACY requires web/node_modules; run npm ci in web first")
endif()
endif()
add_executable(lw_ppocr_web web/lw_web_api.c)
target_link_libraries(lw_ppocr_web PRIVATE lw_ppocr_c)
target_include_directories(lw_ppocr_web PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include")
target_compile_features(lw_ppocr_web PRIVATE c_std_11)
target_compile_options(lw_ppocr_web PRIVATE -O3 -Wall -Wextra -Wpedantic -Werror)
target_compile_definitions(lw_ppocr_web PRIVATE
LW_WEB_ABI_VERSION=${LW_WASM_HOST_ABI_VERSION})
if(LW_WASM_SIMD128)
target_compile_options(lw_ppocr_web PRIVATE -msimd128 -msse2)
target_link_options(lw_ppocr_web PRIVATE -msimd128)
endif()
if(LW_WEB_LEGACY)
target_link_options(lw_ppocr_web PRIVATE
"-sMIN_CHROME_VERSION=${LW_WEB_MIN_CHROME_VERSION}"
"-sENVIRONMENT=web,webview,worker")
endif()
target_link_options(lw_ppocr_web PRIVATE
-O3
"-sMODULARIZE=1" "-sEXPORT_NAME=LwPpocrModule" "-sSINGLE_FILE=1"
"-sFORCE_FILESYSTEM=1" "-sALLOW_MEMORY_GROWTH=1" "-sNO_EXIT_RUNTIME=1"
"-sEXPORTED_RUNTIME_METHODS=['FS','HEAPU8','HEAPU32','HEAPF32']"
"-sEXPORTED_FUNCTIONS=['_lw_web_init','_lw_web_shutdown','_lw_web_info_size','_lw_web_get_info','_lw_web_set_reading_order','_lw_web_run','_lw_web_last_error','_lw_web_malloc','_lw_web_free']"
"--no-entry")
set_target_properties(lw_ppocr_web PROPERTIES OUTPUT_NAME "lw_ppocr_web")
if(NOT LW_DEPLOY_ONNX_MODELS)
add_dependencies(lw_ppocr_web convert_det_model convert_cls_model convert_rec_model)
endif()
# The generated runtime remains a normal Emscripten module. The browser
# SDK is a separate deterministic artifact layered on top of that module,
# so other applications can consume it without the demo HTML.
if(LW_WEB_LEGACY)
set(LW_WEB_OUTPUT_SUFFIX "-legacy")
set(LW_WEB_BUILD_FLAVOR "legacy")
set(LW_WEB_WASM_SIMD128 "false")
set(LW_WEB_PDF_ENABLED "false")
set(LW_WEB_MIN_CHROME_VERSION_VALUE "${LW_WEB_MIN_CHROME_VERSION}")
set(LW_WEB_JS_TARGET_VALUE "chrome${LW_WEB_MIN_CHROME_VERSION}")
set(LW_WEB_HTML_TITLE
"lw.PPOCR.C · PP-OCRv6 Tiny · 兼容版离线 OCR 工作台")
else()
set(LW_WEB_OUTPUT_SUFFIX "")
set(LW_WEB_BUILD_FLAVOR "modern")
if(LW_WASM_SIMD128)
set(LW_WEB_WASM_SIMD128 "true")
else()
set(LW_WEB_WASM_SIMD128 "false")
endif()
if(LW_WEB_PDF)
set(LW_WEB_PDF_ENABLED "true")
else()
set(LW_WEB_PDF_ENABLED "false")
endif()
set(LW_WEB_MIN_CHROME_VERSION_VALUE "")
set(LW_WEB_JS_TARGET_VALUE "")
set(LW_WEB_HTML_TITLE
"lw.PPOCR.C · PP-OCRv6 Tiny · 离线 OCR 工作台")
endif()
if(LW_WEB_LEGACY)
set(LW_PPOCR_C_LEGACY_RUNTIME_JS
"${CMAKE_CURRENT_BINARY_DIR}/lw_ppocr_web.legacy.js")
set(LW_PPOCR_C_LEGACY_RUNTIME_REPORT
"${CMAKE_CURRENT_BINARY_DIR}/legacy-runtime-report.json")
add_custom_command(
OUTPUT
"${LW_PPOCR_C_LEGACY_RUNTIME_JS}"
"${LW_PPOCR_C_LEGACY_RUNTIME_REPORT}"
COMMAND "${LW_NODE_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/web/transpile_legacy_runtime.mjs"
--input "$<TARGET_FILE_DIR:lw_ppocr_web>/lw_ppocr_web.js"
--output "${LW_PPOCR_C_LEGACY_RUNTIME_JS}"
--target "chrome${LW_WEB_MIN_CHROME_VERSION}"
--report "${LW_PPOCR_C_LEGACY_RUNTIME_REPORT}"
DEPENDS
lw_ppocr_web
"${CMAKE_CURRENT_SOURCE_DIR}/web/transpile_legacy_runtime.mjs"
"${CMAKE_CURRENT_SOURCE_DIR}/web/package-lock.json"
"${CMAKE_CURRENT_SOURCE_DIR}/web/node_modules/esbuild/package.json"
COMMENT "Lowering Legacy Web runtime for Chrome ${LW_WEB_MIN_CHROME_VERSION}"
VERBATIM)
add_custom_target(lw-legacy-runtime
DEPENDS
"${LW_PPOCR_C_LEGACY_RUNTIME_JS}"
"${LW_PPOCR_C_LEGACY_RUNTIME_REPORT}")
set(LW_PPOCR_C_WEB_RUNTIME_FOR_PACKAGE
"${LW_PPOCR_C_LEGACY_RUNTIME_JS}")
set(LW_PPOCR_C_WEB_RUNTIME_DEPENDS lw-legacy-runtime)
else()
set(LW_PPOCR_C_WEB_RUNTIME_FOR_PACKAGE
"$<TARGET_FILE_DIR:lw_ppocr_web>/lw_ppocr_web.js")
set(LW_PPOCR_C_WEB_RUNTIME_DEPENDS)
endif()
set(LW_PPOCR_C_WEB_SDK
"${CMAKE_CURRENT_BINARY_DIR}/lw-ppocr${LW_WEB_OUTPUT_SUFFIX}.js")
add_custom_command(
OUTPUT "${LW_PPOCR_C_WEB_SDK}"
COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_sdk.py"
--template "${CMAKE_CURRENT_SOURCE_DIR}/web/lw_ppocr_sdk.template.js"
--runtime "${LW_PPOCR_C_WEB_RUNTIME_FOR_PACKAGE}"
--det "${LW_DEPLOY_DET}" --cls "${LW_DEPLOY_CLS}"
--rec "${LW_DEPLOY_REC}"
--dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--model-family "PP-OCRv6"
--model-variant "tiny"
--model-display-name "PP-OCRv6 Tiny"
--version "${PROJECT_VERSION}"
--build-flavor "${LW_WEB_BUILD_FLAVOR}"
--wasm-simd128 "${LW_WEB_WASM_SIMD128}"
--pdf-enabled "${LW_WEB_PDF_ENABLED}"
--min-chrome-version "${LW_WEB_MIN_CHROME_VERSION_VALUE}"
--js-target "${LW_WEB_JS_TARGET_VALUE}"
--output "${LW_PPOCR_C_WEB_SDK}"
DEPENDS
lw_ppocr_web
${LW_PPOCR_C_WEB_RUNTIME_DEPENDS}
"${CMAKE_CURRENT_SOURCE_DIR}/web/lw_ppocr_sdk.template.js"
"${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_sdk.py"
"${LW_DEPLOY_DET}" "${LW_DEPLOY_CLS}" "${LW_DEPLOY_REC}"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
COMMENT "Packaging the browser OCR SDK"
VERBATIM)
add_custom_target(lw-ocr-js DEPENDS "${LW_PPOCR_C_WEB_SDK}")
# The standalone HTML is now only a thin UI shell plus the SDK. Keep it as
# a separate target so CI and downstream users can download either file.
set(LW_PPOCR_C_WEB_HTML
"${CMAKE_CURRENT_BINARY_DIR}/ocr-demo${LW_WEB_OUTPUT_SUFFIX}.html")
set(LW_PPOCR_C_WEB_HTML_PDF_ARGS --no-pdf)
set(LW_PPOCR_C_WEB_HTML_PDF_DEPENDS)
if(LW_WEB_PDF)
set(LW_PPOCR_C_WEB_HTML_PDF_ARGS
--pdf-adapter "${CMAKE_CURRENT_SOURCE_DIR}/web/pdf/lw_pdf_adapter.js"
--pdfjs-core "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/pdf.min.mjs"
--pdfjs-worker "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/pdf.worker.min.mjs"
--pdfjs-jbig2 "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/jbig2.wasm"
--pdfjs-openjpeg "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/openjpeg.wasm"
--pdfjs-qcms "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/qcms_bg.wasm"
--pdfjs-version "6.3.289")
set(LW_PPOCR_C_WEB_HTML_PDF_DEPENDS
"${CMAKE_CURRENT_SOURCE_DIR}/web/pdf/lw_pdf_adapter.js"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/pdf.min.mjs"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/pdf.worker.min.mjs"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/VERSION"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/jbig2.wasm"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/openjpeg.wasm"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/qcms_bg.wasm"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_JBIG2"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_OPENJPEG"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_PDFJS_JBIG2"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_PDFJS_OPENJPEG"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_PDFJS_QCMS"
"${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_QCMS")
endif()
add_custom_command(
OUTPUT "${LW_PPOCR_C_WEB_HTML}"
COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_html.py"
--template "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo.template.html"
--sdk "${LW_PPOCR_C_WEB_SDK}"
--ui "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo-ui.js"
--sponsor "${CMAKE_CURRENT_SOURCE_DIR}/docs/assets/sponsor.jpg"
--title "${LW_WEB_HTML_TITLE}"
${LW_PPOCR_C_WEB_HTML_PDF_ARGS}
--output "${LW_PPOCR_C_WEB_HTML}"
DEPENDS
lw-ocr-js
"${LW_PPOCR_C_WEB_SDK}"
"${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo.template.html"
"${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo-ui.js"
"${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_html.py"
"${CMAKE_CURRENT_SOURCE_DIR}/docs/assets/sponsor.jpg"
${LW_PPOCR_C_WEB_HTML_PDF_DEPENDS}
COMMENT "Packaging the standalone offline OCR HTML demo"
VERBATIM)
add_custom_target(lw-ocr-html DEPENDS "${LW_PPOCR_C_WEB_HTML}")
# Tiny remains the compatibility/default browser artifact above. Small
# and Medium reuse the same generated WASM runtime and only add their
# model staging plus SDK/HTML wrappers when explicitly requested. This
# keeps the normal browser build fast while providing deterministic,
# independently downloadable model variants for release jobs.
if(LW_BUILD_WEB_MODEL_VARIANTS)
set(LW_WEB_VARIANT_ROOT
"${CMAKE_CURRENT_BINARY_DIR}/runtime-models")
set(LW_WEB_VARIANT_COMMON_DEPS
"${CMAKE_CURRENT_SOURCE_DIR}/tools/prepare_ppocrv6_runtime_variant.py"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-models.json"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-small/det.onnx"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-small/rec.onnx"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-medium/det.onnx"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-medium/rec.onnx"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-shared/PP-OCRv6_small_rec_dict.txt"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/convert_small_det.py"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/convert_small_rec.py"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/convert_medium_det.py"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/convert_medium_rec.py"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/validate_model_catalog.py")
function(lw_add_web_model_variant variant display_name)
set(_variant_conversion_deps)
if(NOT LW_DEPLOY_ONNX_MODELS)
set(_variant_conversion_deps convert_cls_model)
endif()
set(_variant_root
"${LW_WEB_VARIANT_ROOT}/ppocrv6-${variant}")
set(_variant_stage_stamp
"${_variant_root}/runtime-assets.json")
add_custom_command(
OUTPUT "${_variant_stage_stamp}"
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/prepare_ppocrv6_runtime_variant.py"
--variant "${variant}"
--model-format "${LW_DEPLOY_MODEL_FORMAT}"
--build-dir "${CMAKE_CURRENT_BINARY_DIR}"
--output-dir "${_variant_root}"
DEPENDS ${_variant_conversion_deps}
${LW_WEB_VARIANT_COMMON_DEPS}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Staging PP-OCRv6 ${display_name} browser model"
VERBATIM)
set(_variant_sdk
"${CMAKE_CURRENT_BINARY_DIR}/lw-ppocr-v6-${variant}.js")
add_custom_command(
OUTPUT "${_variant_sdk}"
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_sdk.py"
--template "${CMAKE_CURRENT_SOURCE_DIR}/web/lw_ppocr_sdk.template.js"
--runtime "$<TARGET_FILE_DIR:lw_ppocr_web>/lw_ppocr_web.js"
--det "${_variant_root}/det.${LW_DEPLOY_MODEL_FORMAT}"
--cls "${_variant_root}/cls.${LW_DEPLOY_MODEL_FORMAT}"
--rec "${_variant_root}/rec.${LW_DEPLOY_MODEL_FORMAT}"
--dictionary "${_variant_root}/ppocr_keys.txt"
--model-family "PP-OCRv6"
--model-variant "${variant}"
--model-display-name "${display_name}"
--version "${PROJECT_VERSION}"
--build-flavor "${LW_WEB_BUILD_FLAVOR}"
--wasm-simd128 "${LW_WEB_WASM_SIMD128}"
--pdf-enabled "${LW_WEB_PDF_ENABLED}"
--min-chrome-version "${LW_WEB_MIN_CHROME_VERSION_VALUE}"
--output "${_variant_sdk}"
DEPENDS lw_ppocr_web
"${_variant_stage_stamp}"
"${CMAKE_CURRENT_SOURCE_DIR}/web/lw_ppocr_sdk.template.js"
"${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_sdk.py"
COMMENT "Packaging the PP-OCRv6 ${display_name} browser SDK"
VERBATIM)
add_custom_target(lw-ocr-js-${variant} DEPENDS "${_variant_sdk}")
set(_variant_html
"${CMAKE_CURRENT_BINARY_DIR}/ocr-demo-${variant}.html")
add_custom_command(
OUTPUT "${_variant_html}"
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_html.py"
--template "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo.template.html"
--sdk "${_variant_sdk}"
--ui "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo-ui.js"
--sponsor "${CMAKE_CURRENT_SOURCE_DIR}/docs/assets/sponsor.jpg"
--title "lw.PPOCR.C · ${display_name} · 离线 OCR 工作台"
${LW_PPOCR_C_WEB_HTML_PDF_ARGS}
--output "${_variant_html}"
DEPENDS lw-ocr-js-${variant}
"${_variant_sdk}"
"${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo.template.html"
"${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo-ui.js"
"${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_html.py"
"${CMAKE_CURRENT_SOURCE_DIR}/docs/assets/sponsor.jpg"
${LW_PPOCR_C_WEB_HTML_PDF_DEPENDS}
COMMENT "Packaging the PP-OCRv6 ${display_name} offline OCR HTML"
VERBATIM)
add_custom_target(lw-ocr-html-${variant} DEPENDS "${_variant_html}")
endfunction()
lw_add_web_model_variant(small "PP-OCRv6 Small")
lw_add_web_model_variant(medium "PP-OCRv6 Medium")
add_custom_target(lw-ocr-js-all
DEPENDS lw-ocr-js lw-ocr-js-small lw-ocr-js-medium)
add_custom_target(lw-ocr-html-all
DEPENDS lw-ocr-html lw-ocr-html-small lw-ocr-html-medium)
endif()
if(NOT LW_WEB_LEGACY)
# Node consumes the same WASM Host ABI as the browser. Keep this target
# separate from the browser SDK so the Node release never needs to parse
# or extract assets from ocr-demo.html.
add_executable(lw_ppocr_node web/lw_web_api.c)
target_link_libraries(lw_ppocr_node PRIVATE lw_ppocr_c)
target_include_directories(lw_ppocr_node PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include")
target_compile_features(lw_ppocr_node PRIVATE c_std_11)
target_compile_options(lw_ppocr_node PRIVATE -O3 -Wall -Wextra -Wpedantic -Werror)
target_compile_definitions(lw_ppocr_node PRIVATE
LW_WEB_ABI_VERSION=${LW_WASM_HOST_ABI_VERSION})
if(LW_WASM_SIMD128)
target_compile_options(lw_ppocr_node PRIVATE -msimd128 -msse2)
target_link_options(lw_ppocr_node PRIVATE -msimd128)
endif()
if(LW_WASM_COMPILED_REC_ENABLED)
# Only the experimental Node package accepts the C profiler switch.
# The browser SDK and canonical Node package keep their normal env policy.
target_include_directories(lw_ppocr_node PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_definitions(lw_ppocr_node PRIVATE LW_NODE_WASM_PROFILE=1)
endif()
target_link_options(lw_ppocr_node PRIVATE
-O3
"-sMODULARIZE=1" "-sEXPORT_NAME=LwPpocrModule" "-sSINGLE_FILE=1"
"-sENVIRONMENT=node" "-sFORCE_FILESYSTEM=1" "-sALLOW_MEMORY_GROWTH=1"
"-sNO_EXIT_RUNTIME=1"
"-sEXPORTED_RUNTIME_METHODS=['FS','HEAPU8','HEAPU32','HEAPF32']"
"-sEXPORTED_FUNCTIONS=['_lw_web_init','_lw_web_shutdown','_lw_web_info_size','_lw_web_get_info','_lw_web_set_reading_order','_lw_web_run','_lw_web_last_error','_lw_web_malloc','_lw_web_free']"
"--no-entry")
set_target_properties(lw_ppocr_node PROPERTIES OUTPUT_NAME "lw_ppocr_node")
if(NOT LW_DEPLOY_ONNX_MODELS)
add_dependencies(lw_ppocr_node convert_det_model convert_cls_model convert_rec_model)
endif()
if(LW_WASM_SIMD128)
set(LW_NODE_WASM_BACKEND wasm128)
else()
set(LW_NODE_WASM_BACKEND scalar)
endif()
set(LW_PPOCR_C_NODE_RUNTIME
"${CMAKE_CURRENT_BINARY_DIR}/runtime.cjs")
add_custom_command(
OUTPUT "${LW_PPOCR_C_NODE_RUNTIME}"
COMMAND "${CMAKE_COMMAND}" -E make_directory
"${CMAKE_CURRENT_BINARY_DIR}/node-wasm"
COMMAND "${CMAKE_COMMAND}" -E copy
"$<TARGET_FILE:lw_ppocr_node>" "${LW_PPOCR_C_NODE_RUNTIME}"
DEPENDS lw_ppocr_node
COMMENT "Preparing the Node.js WASM runtime"
VERBATIM)
add_custom_target(lw-node-wasm DEPENDS "${LW_PPOCR_C_NODE_RUNTIME}")
set(LW_PPOCR_C_NODE_PACKAGE_DIR
"${CMAKE_CURRENT_BINARY_DIR}/node-wasm")
set(LW_PPOCR_C_NODE_PACKAGE_ARCHIVE
"${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.C-${PROJECT_VERSION}-node-wasm.zip")
set(LW_PPOCR_C_NODE_PACKAGE_CHECKSUM
"${LW_PPOCR_C_NODE_PACKAGE_ARCHIVE}.sha256")
add_custom_command(
OUTPUT "${LW_PPOCR_C_NODE_PACKAGE_ARCHIVE}"
"${LW_PPOCR_C_NODE_PACKAGE_CHECKSUM}"
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/package_node_wasm.py"
--runtime "${LW_PPOCR_C_NODE_RUNTIME}"
--det "${LW_DEPLOY_DET}"
--cls "${LW_DEPLOY_CLS}"
--rec "${LW_DEPLOY_REC}"
--dictionary
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--license "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE"
--model-license
"${CMAKE_CURRENT_SOURCE_DIR}/licenses/PaddleOCR-models-APACHE-2.0.txt"
--notices "${CMAKE_CURRENT_SOURCE_DIR}/THIRD-PARTY-NOTICES.md"
--version "${PROJECT_VERSION}"
--wasm-backend "${LW_NODE_WASM_BACKEND}"
--wasm-host-abi-version "${LW_WASM_HOST_ABI_VERSION}"
--lwm-version "${LW_LWM_FORMAT_VERSION}"
--output-dir "${LW_PPOCR_C_NODE_PACKAGE_DIR}"
--archive "${LW_PPOCR_C_NODE_PACKAGE_ARCHIVE}"
DEPENDS lw-node-wasm "${LW_PPOCR_C_NODE_RUNTIME}"
"${LW_DEPLOY_DET}" "${LW_DEPLOY_CLS}" "${LW_DEPLOY_REC}"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/package_node_wasm.py"
"${CMAKE_CURRENT_SOURCE_DIR}/LICENSE"
"${CMAKE_CURRENT_SOURCE_DIR}/licenses/PaddleOCR-models-APACHE-2.0.txt"
"${CMAKE_CURRENT_SOURCE_DIR}/THIRD-PARTY-NOTICES.md"
COMMENT "Packaging the Node.js WASM distribution"
VERBATIM)
add_custom_target(lw-node-wasm-package
DEPENDS "${LW_PPOCR_C_NODE_PACKAGE_ARCHIVE}"
"${LW_PPOCR_C_NODE_PACKAGE_CHECKSUM}")
endif()
endif()
if(EMSCRIPTEN AND LW_WASM_SIMD128)
add_executable(wasm-erf-contract tests/wasm_erf_contract_driver.c)
target_include_directories(wasm-erf-contract PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd"
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
target_compile_features(wasm-erf-contract PRIVATE c_std_11)
target_compile_options(wasm-erf-contract PRIVATE
-O3 -Wall -Wextra -Wpedantic -Werror -msimd128)
target_link_options(wasm-erf-contract PRIVATE -O3 -msimd128 "-sENVIRONMENT=node")
endif()
if(LW_WASM_COMPILED_REC_ENABLED)
add_executable(wasm-pointwise-contract tests/wasm_pointwise_contract_driver.c)
target_include_directories(wasm-pointwise-contract PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd"
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
target_compile_features(wasm-pointwise-contract PRIVATE c_std_11)
target_compile_options(wasm-pointwise-contract PRIVATE
-O3 -Wall -Wextra -Wpedantic -Werror -msimd128)
target_link_libraries(wasm-pointwise-contract PRIVATE lw_ppocr_c)
target_link_options(wasm-pointwise-contract PRIVATE -O3 -msimd128 "-sENVIRONMENT=node")
# Keep the bitwise generic/prepared kernel contract even though the
# compiled prepared-offset experiment did not meet the E2E threshold.
add_executable(wasm-dense-prepared-contract tests/wasm_dense_prepared_contract_driver.c)
target_include_directories(wasm-dense-prepared-contract PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
target_compile_features(wasm-dense-prepared-contract PRIVATE c_std_11)
target_compile_options(wasm-dense-prepared-contract PRIVATE
-O3 -Wall -Wextra -Wpedantic -Werror -msimd128)
target_link_libraries(wasm-dense-prepared-contract PRIVATE lw_ppocr_c)
target_link_options(wasm-dense-prepared-contract PRIVATE -O3 -msimd128 "-sENVIRONMENT=node")
endif()
if(EMSCRIPTEN AND LW_WASM_REC_LAZY_FALLBACK)
# Private CI executable: exercise a source whose canonical REC session was
# released, a compiled clone, and a clone forced onto canonical fallback.
add_executable(wasm-rec-lazy-contract tests/wasm_rec_lazy_contract_driver.c)
target_link_libraries(wasm-rec-lazy-contract PRIVATE lw_ppocr_c m)
target_include_directories(wasm-rec-lazy-contract PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_features(wasm-rec-lazy-contract PRIVATE c_std_11)
target_compile_definitions(wasm-rec-lazy-contract PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
if(LW_WASM_FINE_REC_WIDTHS)
target_compile_definitions(wasm-rec-lazy-contract PRIVATE LW_WASM_FINE_REC_WIDTHS=1)
endif()
target_compile_options(wasm-rec-lazy-contract PRIVATE
-O3 -Wall -Wextra -Wpedantic -Werror -msimd128)
target_link_options(wasm-rec-lazy-contract PRIVATE
-O3 -msimd128 "-sENVIRONMENT=node" "-sFORCE_FILESYSTEM=1"
"-sALLOW_MEMORY_GROWTH=1"
"SHELL:--embed-file \"${LW_PPOCR_C_REC_LWM}@/models/rec.lwm\""
"SHELL:--embed-file \"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt@/models/ppocr_keys.txt\"")
add_dependencies(wasm-rec-lazy-contract convert_rec_model)
endif()
set(LW_PPOCR_C_REC_DEMO_PPM
"${CMAKE_CURRENT_BINARY_DIR}/models/sample-crop.ppm")
if(LW_PRECONVERTED_ASSETS_DIR)
add_custom_command(
OUTPUT "${LW_PPOCR_C_REC_DEMO_PPM}"
COMMAND "${CMAKE_COMMAND}" -E make_directory
"${CMAKE_CURRENT_BINARY_DIR}/models"
COMMAND "${CMAKE_COMMAND}" -E copy_if_different
"${LW_PRECONVERTED_ASSETS_DIR}/sample-crop.ppm"
"${LW_PPOCR_C_REC_DEMO_PPM}"
DEPENDS "${LW_PRECONVERTED_ASSETS_DIR}/sample-crop.ppm"
COMMENT "Copying preconverted REC demo fixture"
VERBATIM)
else()
add_custom_command(
OUTPUT "${LW_PPOCR_C_REC_DEMO_PPM}"
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/create_rec_demo_fixture.py"
--input "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
--output "${LW_PPOCR_C_REC_DEMO_PPM}"
DEPENDS
"${CMAKE_CURRENT_SOURCE_DIR}/tools/create_rec_demo_fixture.py"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
COMMENT "Creating dependency-free REC demo PPM fixture"
VERBATIM)
endif()
add_custom_target(rec_demo_fixture ALL DEPENDS "${LW_PPOCR_C_REC_DEMO_PPM}")
set(LW_PPOCR_C_DET_DEMO_PPM
"${CMAKE_CURRENT_BINARY_DIR}/models/sample.ppm")
if(LW_PRECONVERTED_ASSETS_DIR)
add_custom_command(
OUTPUT "${LW_PPOCR_C_DET_DEMO_PPM}"
COMMAND "${CMAKE_COMMAND}" -E make_directory
"${CMAKE_CURRENT_BINARY_DIR}/models"
COMMAND "${CMAKE_COMMAND}" -E copy_if_different
"${LW_PRECONVERTED_ASSETS_DIR}/sample.ppm"
"${LW_PPOCR_C_DET_DEMO_PPM}"
DEPENDS "${LW_PRECONVERTED_ASSETS_DIR}/sample.ppm"
COMMENT "Copying preconverted DET demo fixture"
VERBATIM)
else()
add_custom_command(
OUTPUT "${LW_PPOCR_C_DET_DEMO_PPM}"
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/create_det_demo_fixture.py"
--input "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
--output "${LW_PPOCR_C_DET_DEMO_PPM}"
DEPENDS
"${CMAKE_CURRENT_SOURCE_DIR}/tools/create_det_demo_fixture.py"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
COMMENT "Creating dependency-free DET demo PPM fixture"
VERBATIM)
endif()
add_custom_target(det_demo_fixture ALL DEPENDS "${LW_PPOCR_C_DET_DEMO_PPM}")
if(NOT EMSCRIPTEN)
add_executable(lw-recognize-ppm examples/recognize_ppm.c)
target_link_libraries(lw-recognize-ppm PRIVATE lw_ppocr_c_shared)
target_compile_features(lw-recognize-ppm PRIVATE c_std_11)
add_dependencies(lw-recognize-ppm convert_rec_model rec_demo_fixture)
if(WIN32)
target_link_libraries(lw-recognize-ppm PRIVATE shell32)
elseif(APPLE)
set_target_properties(lw-recognize-ppm PROPERTIES INSTALL_RPATH "@loader_path/../lib")
else()
set_target_properties(lw-recognize-ppm PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
endif()
add_executable(lw-rec-benchmark examples/benchmark_ppm.c)
target_sources(lw-rec-benchmark PRIVATE src/simd/cpu_features.c)
target_link_libraries(lw-rec-benchmark PRIVATE lw_ppocr_c_shared)
target_include_directories(lw-rec-benchmark PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(lw-rec-benchmark PRIVATE c_std_11)
add_dependencies(lw-rec-benchmark convert_rec_model rec_demo_fixture)
if(WIN32)
target_link_libraries(lw-rec-benchmark PRIVATE shell32 psapi)
elseif(APPLE)
set_target_properties(lw-rec-benchmark PROPERTIES
INSTALL_RPATH "@loader_path/../lib")
else()
set_target_properties(lw-rec-benchmark PROPERTIES
INSTALL_RPATH "$ORIGIN/../lib")
endif()
add_executable(lw-ocr-benchmark examples/ocr_benchmark_ppm.c)
target_sources(lw-ocr-benchmark PRIVATE src/simd/cpu_features.c)
target_link_libraries(lw-ocr-benchmark PRIVATE lw_ppocr_c_shared)
target_include_directories(lw-ocr-benchmark PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(lw-ocr-benchmark PRIVATE c_std_11)
add_dependencies(lw-ocr-benchmark convert_det_model convert_cls_model
convert_rec_model det_demo_fixture)
if(WIN32)
target_link_libraries(lw-ocr-benchmark PRIVATE shell32 psapi)
elseif(APPLE)
set_target_properties(lw-ocr-benchmark PROPERTIES
INSTALL_RPATH "@loader_path/../lib")
else()
set_target_properties(lw-ocr-benchmark PROPERTIES
INSTALL_RPATH "$ORIGIN/../lib")
endif()
add_executable(lw-classify-ppm examples/classify_ppm.c)
target_link_libraries(lw-classify-ppm PRIVATE lw_ppocr_c_shared)
target_compile_features(lw-classify-ppm PRIVATE c_std_11)
add_dependencies(lw-classify-ppm convert_cls_model rec_demo_fixture)
if(WIN32)
target_link_libraries(lw-classify-ppm PRIVATE shell32)
elseif(APPLE)
set_target_properties(lw-classify-ppm PROPERTIES INSTALL_RPATH "@loader_path/../lib")
else()
set_target_properties(lw-classify-ppm PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
endif()
add_executable(lw-detect-ppm examples/detect_ppm.c)
target_link_libraries(lw-detect-ppm PRIVATE lw_ppocr_c_shared)
target_compile_features(lw-detect-ppm PRIVATE c_std_11)
add_dependencies(lw-detect-ppm convert_det_model det_demo_fixture)
if(WIN32)
target_link_libraries(lw-detect-ppm PRIVATE shell32)
elseif(APPLE)
set_target_properties(lw-detect-ppm PROPERTIES INSTALL_RPATH "@loader_path/../lib")
else()
set_target_properties(lw-detect-ppm PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
endif()
add_executable(lw-ocr-ppm examples/ocr_ppm.c)
target_link_libraries(lw-ocr-ppm PRIVATE lw_ppocr_c_shared)
target_compile_features(lw-ocr-ppm PRIVATE c_std_11)
add_dependencies(lw-ocr-ppm convert_det_model convert_cls_model
convert_rec_model det_demo_fixture)
if(WIN32)
target_link_libraries(lw-ocr-ppm PRIVATE shell32)
elseif(APPLE)
set_target_properties(lw-ocr-ppm PROPERTIES INSTALL_RPATH "@loader_path/../lib")
else()
set_target_properties(lw-ocr-ppm PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
endif()
if(MSVC)
target_compile_options(lw-classify-ppm PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(lw-classify-ppm PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
target_compile_options(lw-detect-ppm PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(lw-detect-ppm PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
target_compile_options(lw-ocr-ppm PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(lw-ocr-ppm PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
target_compile_options(lw-rec-benchmark PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(lw-rec-benchmark PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
target_compile_options(lw-ocr-benchmark PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(lw-ocr-benchmark PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
target_compile_options(lw-recognize-ppm PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(lw-recognize-ppm PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_executable(lwm-inspect tools/lwm_inspect.c)
target_link_libraries(lwm-inspect PRIVATE lw_ppocr_c)
if(WIN32)
target_link_libraries(lwm-inspect PRIVATE shell32)
endif()
target_compile_features(lwm-inspect PRIVATE c_std_11)
if(MSVC)
target_compile_options(lwm-inspect PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(lwm-inspect PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
if(LW_BUILD_HTTP_DEMO)
set(LW_HTTPLIB_HEADER
"${CMAKE_CURRENT_SOURCE_DIR}/examples/http-server/third_party/httplib.h")
file(SHA256 "${LW_HTTPLIB_HEADER}" LW_HTTPLIB_SHA256)
if(NOT LW_HTTPLIB_SHA256 STREQUAL
"1c8b44c8ab0498322c08840dbdfcd5006bc28c5a3b140b0c2cf30777b7232fc6")
message(FATAL_ERROR "vendored cpp-httplib checksum mismatch")
endif()
configure_file(
examples/http-server/www/index.html
"${CMAKE_CURRENT_BINARY_DIR}/www/index.html"
COPYONLY)
add_executable(lw-http-ocr examples/http-server/main.cpp)
set_target_properties(lw-http-ocr PROPERTIES
OUTPUT_NAME "lw.PPOCR.C.HttpServer"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
foreach(lw_config Debug Release RelWithDebInfo MinSizeRel)
string(TOUPPER "${lw_config}" lw_config_upper)
set_target_properties(lw-http-ocr PROPERTIES
"RUNTIME_OUTPUT_DIRECTORY_${lw_config_upper}"
"${CMAKE_CURRENT_BINARY_DIR}/bin")
endforeach()
target_include_directories(lw-http-ocr PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/include")
target_include_directories(lw-http-ocr SYSTEM PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/examples/http-server/third_party")
target_link_libraries(lw-http-ocr PRIVATE lw_ppocr_c)
target_compile_features(lw-http-ocr PRIVATE cxx_std_11)
add_dependencies(lw-http-ocr convert_det_model convert_cls_model
convert_rec_model)
if(WIN32)
target_compile_definitions(lw-http-ocr PRIVATE
WINVER=0x0601 _WIN32_WINNT=0x0601
WIN32_LEAN_AND_MEAN NOMINMAX)
target_link_libraries(lw-http-ocr PRIVATE ws2_32)
elseif(UNIX AND NOT APPLE)
target_link_libraries(lw-http-ocr PRIVATE pthread)
endif()
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
target_compile_definitions(lw-http-ocr PRIVATE
LW_HTTP_THREAD_POOL_COUNT=2)
endif()
if(MSVC)
target_compile_options(lw-http-ocr PRIVATE /W4 /WX /utf-8)
target_link_options(lw-http-ocr PRIVATE
/SUBSYSTEM:CONSOLE,6.01
$<$<EQUAL:${CMAKE_SIZEOF_VOID_P},4>:/LARGEADDRESSAWARE>)
else()
target_compile_options(lw-http-ocr PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_custom_command(TARGET lw-http-ocr POST_BUILD
COMMAND "${CMAKE_COMMAND}" -E copy_if_different
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
"${CMAKE_CURRENT_BINARY_DIR}/models/ppocr_keys.txt"
VERBATIM)
endif()
if(LW_BUILD_CSHARP_DEMOS)
if(NOT WIN32)
message(FATAL_ERROR "LW_BUILD_CSHARP_DEMOS is supported only on Windows")
endif()
find_program(LW_MSBUILD_EXECUTABLE NAMES MSBuild.exe msbuild REQUIRED)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(LW_MANAGED_PLATFORM x64)
else()
set(LW_MANAGED_PLATFORM x86)
endif()
set(LW_MANAGED_ROOT "${CMAKE_CURRENT_BINARY_DIR}/managed")
set(LW_MANAGED_WINFORMS_DIR "${LW_MANAGED_ROOT}/winforms")
set(LW_MANAGED_MODELS_DIR "${LW_MANAGED_ROOT}/models")
set(LW_MANAGED_WINFORMS_EXE
"${LW_MANAGED_WINFORMS_DIR}/lw.PPOCR.C.WinForms.exe")
add_custom_target(lw-csharp-demos ALL
COMMAND "${CMAKE_COMMAND}" -E make_directory
"${LW_MANAGED_WINFORMS_DIR}" "${LW_MANAGED_MODELS_DIR}"
COMMAND "${LW_MSBUILD_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-winforms/LwPpocrWinForms.csproj"
-t:Restore -p:RestorePackagesConfig=true
-p:RestoreIgnoreFailedSources=true -p:NuGetAudit=false -v:minimal
COMMAND "${LW_MSBUILD_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-winforms/LwPpocrWinForms.csproj"
-t:Rebuild -p:Configuration=Release
-p:Platform=${LW_MANAGED_PLATFORM}
"-p:OutputPath=${LW_MANAGED_WINFORMS_DIR}/" -v:minimal
COMMAND "${CMAKE_COMMAND}" -E copy_if_different
"$<TARGET_FILE:lw_ppocr_c_shared>"
"${LW_MANAGED_WINFORMS_DIR}/"
COMMAND "${CMAKE_COMMAND}" -E copy_if_different
"${LW_PPOCR_C_DET_LWM}" "${LW_PPOCR_C_CLS_LWM}"
"${LW_PPOCR_C_REC_LWM}"
"${LW_PPOCR_C_DET_ONNX}" "${LW_PPOCR_C_CLS_ONNX}" "${LW_PPOCR_C_REC_ONNX}"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/model.json"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
"${LW_MANAGED_MODELS_DIR}/"
DEPENDS
lw_ppocr_c_shared
convert_det_model convert_cls_model convert_rec_model
"${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-common/NativeOcr.cs"
"${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-common/OcrModels.cs"
"${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-winforms/MainForm.cs"
"${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-winforms/OcrResultExporter.cs"
COMMENT "Building .NET Framework 3.5 WinForms OCR Demo"
VERBATIM)
endif()
endif()
if(BUILD_TESTING AND NOT EMSCRIPTEN)
add_executable(wasm-ctc-projection-driver
tests/test_wasm_ctc_projection.c
src/simd/wasm128_packed_matmul.c
src/kernels/packed_matmul.c)
target_include_directories(wasm-ctc-projection-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
target_compile_features(wasm-ctc-projection-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(wasm-ctc-projection-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(wasm-ctc-projection-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
target_link_libraries(wasm-ctc-projection-driver PRIVATE m)
endif()
add_test(NAME wasm_ctc_projection COMMAND wasm-ctc-projection-driver)
add_executable(avx2-ctc-projection-driver tests/test_avx2_ctc_projection.c)
target_link_libraries(avx2-ctc-projection-driver PRIVATE lw_ppocr_c)
target_include_directories(avx2-ctc-projection-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(avx2-ctc-projection-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(avx2-ctc-projection-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(avx2-ctc-projection-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
target_link_libraries(avx2-ctc-projection-driver PRIVATE m)
endif()
add_test(NAME avx2_ctc_projection_tails COMMAND avx2-ctc-projection-driver)
set_tests_properties(avx2_ctc_projection_tails PROPERTIES SKIP_RETURN_CODE 77)
add_executable(nhwc-depthwise-portable-driver
tests/test_nhwc_depthwise_portable.c
src/simd/avx2_nhwc_depthwise.c)
target_include_directories(nhwc-depthwise-portable-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
target_compile_features(nhwc-depthwise-portable-driver PRIVATE c_std_11)
target_compile_definitions(nhwc-depthwise-portable-driver PRIVATE
LW_NHWC_FORCE_PORTABLE=1)
if(MSVC)
target_compile_options(nhwc-depthwise-portable-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(nhwc-depthwise-portable-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME nhwc_depthwise_portable COMMAND nhwc-depthwise-portable-driver)
foreach(policy IN ITEMS default fine)
add_executable(rec-width-policy-${policy} tests/rec_width_policy_driver.c)
target_include_directories(rec-width-policy-${policy} PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_features(rec-width-policy-${policy} PRIVATE c_std_11)
if(policy STREQUAL "fine")
target_compile_definitions(rec-width-policy-${policy} PRIVATE
LW_NATIVE_FINE_REC_WIDTHS=1 LW_TEST_FINE_WIDTHS=1)
endif()
if(MSVC)
target_compile_options(rec-width-policy-${policy} PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(rec-width-policy-${policy} PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME rec_width_policy_${policy} COMMAND rec-width-policy-${policy})
endforeach()
add_test(NAME onnx_e2e_comparison_contract
COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_onnx_e2e_comparison)
set_tests_properties(onnx_e2e_comparison_contract PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 30)
if(WIN32 AND MSVC AND CMAKE_SIZEOF_VOID_P EQUAL 8 AND
MSVC_C_ARCHITECTURE_ID MATCHES "^(x64|X86)$")
add_test(NAME csharp_image_limits_contract
COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_csharp_image_limits.py"
--native "$<TARGET_FILE:lw_ppocr_c_shared>")
set_tests_properties(csharp_image_limits_contract PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 240)
endif()
add_test(NAME web_release_profile_contract
COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_web_release_profile)
set_tests_properties(web_release_profile_contract PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 30)
add_test(NAME winforms_release_version_contract
COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_winforms_release)
set_tests_properties(winforms_release_version_contract PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 30)
add_test(NAME native_rec_quality_contract
COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_native_rec_quality)
set_tests_properties(native_rec_quality_contract PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 30)
add_test(
NAME source_final_newline_contract
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_source_newlines.py"
--root "${CMAKE_CURRENT_SOURCE_DIR}")
set_tests_properties(source_final_newline_contract PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 30)
set(LW_RESHAPE_FIXTURE_DIR "${CMAKE_CURRENT_BINARY_DIR}/test-fixtures")
set(LW_RESHAPE_FIXTURES
"${LW_RESHAPE_FIXTURE_DIR}/valid.lwm"
"${LW_RESHAPE_FIXTURE_DIR}/two-unknown.lwm"
"${LW_RESHAPE_FIXTURE_DIR}/non-divisible.lwm"
"${LW_RESHAPE_FIXTURE_DIR}/zero.lwm"
"${LW_RESHAPE_FIXTURE_DIR}/overflow.lwm")
add_custom_command(
OUTPUT ${LW_RESHAPE_FIXTURES}
COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tools/create_reshape_test_models.py"
--output-dir "${LW_RESHAPE_FIXTURE_DIR}"
DEPENDS
"${CMAKE_CURRENT_SOURCE_DIR}/tools/create_reshape_test_models.py"
"${CMAKE_CURRENT_SOURCE_DIR}/converter/lwm_v0.py"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Creating direct dynamic Reshape contract fixtures"
VERBATIM)
add_custom_target(dynamic_reshape_fixtures DEPENDS ${LW_RESHAPE_FIXTURES})
add_executable(test-dynamic-reshape tests/reshape_dynamic_driver.c)
target_link_libraries(test-dynamic-reshape PRIVATE lw_ppocr_c)
target_compile_features(test-dynamic-reshape PRIVATE c_std_11)
add_dependencies(test-dynamic-reshape dynamic_reshape_fixtures)
if(MSVC)
target_compile_options(test-dynamic-reshape PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(test-dynamic-reshape PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME dynamic_reshape_contract
COMMAND test-dynamic-reshape ${LW_RESHAPE_FIXTURES})
add_test(
NAME model_analysis
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_analyze_onnx tests.test_compare_model_analysis
tests.test_cls_identity tests.test_model_contract
tests.test_small_validation_bundle
tests.test_model_catalog
tests.test_model_manifest
tests.test_probe_rec_shape_metadata
tests.test_small_contracts
tests.test_medium_contracts
tests.test_ocr_dataset
tests.test_generate_ocr_dataset
tests.test_prepare_ocr_dataset_ppm
tests.test_build_ocr_width_switch_manifest
tests.test_compare_ocr_dataset_runtime
tests.test_collect_rec_shape_profile
tests.test_collect_det_shape_profile
tests.test_compare_ocr_dataset_reports
tests.test_build_engine_comparison_report
tests.test_layout_plan_snapshot
tests.test_summarize_ocr_dataset_reports
tests.test_check_ocr_dataset_regression
tests.test_experimental_ops tests.test_small_ocr_baseline
tests.test_runtime_model_pack
tests.test_release_assets
tests.test_web_ocr_contracts
tests.test_versioning)
set_tests_properties(model_analysis PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME release_metadata_consistency
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tools/check_release_readiness.py"
--mode preview
--version "${PROJECT_VERSION}")
set_tests_properties(release_metadata_consistency PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME wasm_host_abi_contract
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_web_abi_contract)
set_tests_properties(wasm_host_abi_contract PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME conv_shape_analysis
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_analyze_conv_shapes)
set_tests_properties(conv_shape_analysis PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME rec_aot_pattern_analysis
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_analyze_rec_aot_patterns)
set_tests_properties(rec_aot_pattern_analysis PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME ocr_dispatch_profile_comparison
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_compare_ocr_dispatch_profiles)
set_tests_properties(ocr_dispatch_profile_comparison PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME rec_runtime_profile_comparison
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_compare_rec_runtime_profiles)
set_tests_properties(rec_runtime_profile_comparison PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME opencv_dnn_comparison_helpers
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_compare_opencv_dnn)
set_tests_properties(opencv_dnn_comparison_helpers PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME conv_bn_fusion
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_conv_bn_fusion)
set_tests_properties(conv_bn_fusion PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME rec_converter
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_convert_rec)
set_tests_properties(rec_converter PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME cls_converter
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_convert_cls)
set_tests_properties(cls_converter PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME det_converter
COMMAND "${Python3_EXECUTABLE}" -m unittest -v
tests.test_convert_det)
set_tests_properties(det_converter PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_executable(test-lwm-loader tests/test_model.c)
target_link_libraries(test-lwm-loader PRIVATE lw_ppocr_c)
target_compile_features(test-lwm-loader PRIVATE c_std_11)
add_dependencies(test-lwm-loader convert_rec_model)
if(MSVC)
target_compile_options(test-lwm-loader PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(test-lwm-loader PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME lwm_loader COMMAND test-lwm-loader "${LW_PPOCR_C_REC_LWM}")
add_executable(test-crop-buffer tests/test_crop_buffer.c)
target_link_libraries(test-crop-buffer PRIVATE lw_ppocr_c)
target_include_directories(test-crop-buffer PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_features(test-crop-buffer PRIVATE c_std_11)
if(MSVC)
target_compile_options(test-crop-buffer PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(test-crop-buffer PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME crop_buffer COMMAND test-crop-buffer)
add_executable(test-session-planner tests/test_session.c)
target_link_libraries(test-session-planner PRIVATE lw_ppocr_c)
target_include_directories(test-session-planner PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
if(LW_EXPERIMENTAL_PREPARED_EXECUTION)
target_compile_definitions(test-session-planner PRIVATE LW_EXPERIMENTAL_PREPARED_EXECUTION=1)
endif()
target_compile_features(test-session-planner PRIVATE c_std_11)
add_dependencies(test-session-planner convert_rec_model)
if(MSVC)
target_compile_options(test-session-planner PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(test-session-planner PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME session_planner COMMAND test-session-planner "${LW_PPOCR_C_REC_LWM}")
add_executable(layout-plan-driver
tests/layout_plan_driver.c
src/runtime/layout_planner.c)
target_link_libraries(layout-plan-driver PRIVATE lw_ppocr_c)
target_include_directories(layout-plan-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
target_compile_features(layout-plan-driver PRIVATE c_std_11)
add_dependencies(layout-plan-driver convert_rec_model convert_det_model)
if(MSVC)
target_compile_options(layout-plan-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(layout-plan-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME layout_plan_analysis
COMMAND layout-plan-driver "${LW_PPOCR_C_REC_LWM}" 48 960)
add_test(NAME layout_plan_direct_input
COMMAND layout-plan-driver "${LW_PPOCR_C_REC_LWM}" 48 960 direct-nhwc)
add_test(NAME layout_plan_det
COMMAND layout-plan-driver "${LW_PPOCR_C_DET_LWM}" 640 640 direct-nhwc)
add_executable(workspace-report-driver tests/workspace_report_driver.c)
target_link_libraries(workspace-report-driver PRIVATE lw_ppocr_c)
target_include_directories(workspace-report-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
target_compile_features(workspace-report-driver PRIVATE c_std_11)
add_dependencies(workspace-report-driver convert_rec_model)
if(MSVC)
target_compile_options(workspace-report-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(workspace-report-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
if(LW_EXPERIMENTAL_CTC_TILED)
target_compile_definitions(workspace-report-driver PRIVATE LW_EXPERIMENTAL_CTC_TILED=1)
endif()
add_test(NAME workspace_memory_report
COMMAND workspace-report-driver "${LW_PPOCR_C_REC_LWM}" 320 1)
add_test(NAME workspace_ctc_memory_report
COMMAND workspace-report-driver "${LW_PPOCR_C_REC_LWM}" 320 1 --ctc-greedy)
add_executable(test-cpu-topology tests/test_cpu_topology.c)
target_link_libraries(test-cpu-topology PRIVATE lw_ppocr_c)
target_include_directories(test-cpu-topology PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
target_compile_features(test-cpu-topology PRIVATE c_std_11)
if(MSVC)
target_compile_options(test-cpu-topology PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(test-cpu-topology PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME cpu_topology_policy COMMAND test-cpu-topology)
add_executable(test-c-abi tests/test_abi.c)
target_link_libraries(test-c-abi PRIVATE lw_ppocr_c)
target_compile_features(test-c-abi PRIVATE c_std_11)
if(MSVC)
target_compile_options(test-c-abi PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(test-c-abi PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME c_abi_contract COMMAND test-c-abi)
add_executable(test-c-abi-prefix tests/test_abi_prefix.c)
target_link_libraries(test-c-abi-prefix PRIVATE lw_ppocr_c)
target_compile_features(test-c-abi-prefix PRIVATE c_std_11)
add_dependencies(test-c-abi-prefix convert_det_model convert_cls_model convert_rec_model)
if(MSVC)
target_compile_options(test-c-abi-prefix PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(test-c-abi-prefix PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME c_abi_prefix_compatibility
COMMAND test-c-abi-prefix
"${LW_PPOCR_C_DET_LWM}"
"${LW_PPOCR_C_CLS_LWM}"
"${LW_PPOCR_C_REC_LWM}"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt")
add_executable(abi-layout-driver tests/abi_layout_driver.c)
target_include_directories(abi-layout-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/include")
target_compile_features(abi-layout-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(abi-layout-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(abi-layout-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME abi_layout_contract
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_abi_layout.py"
--driver "$<TARGET_FILE:abi-layout-driver>"
--manifest "${CMAKE_CURRENT_SOURCE_DIR}/abi/c-abi-v1-layout.json")
add_test(
NAME lwm_layout_contract
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_lwm_layout.py"
--manifest "${CMAKE_CURRENT_SOURCE_DIR}/abi/lwm-v0.1-layout.json"
--model "${LW_PPOCR_C_DET_LWM}"
--model "${LW_PPOCR_C_CLS_LWM}"
--model "${LW_PPOCR_C_REC_LWM}")
set_tests_properties(lwm_layout_contract PROPERTIES
DEPENDS "det_converter;cls_converter;rec_converter")
add_executable(test-recognizer-api tests/test_recognizer.c)
target_link_libraries(test-recognizer-api PRIVATE lw_ppocr_c)
target_compile_features(test-recognizer-api PRIVATE c_std_11)
add_dependencies(test-recognizer-api convert_rec_model)
if(MSVC)
target_compile_options(test-recognizer-api PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(test-recognizer-api PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME recognizer_api_contract
COMMAND test-recognizer-api
"${LW_PPOCR_C_REC_LWM}"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt")
add_executable(test-classifier-api tests/test_classifier.c)
target_link_libraries(test-classifier-api PRIVATE lw_ppocr_c)
target_compile_features(test-classifier-api PRIVATE c_std_11)
add_dependencies(test-classifier-api convert_cls_model)
if(MSVC)
target_compile_options(test-classifier-api PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(test-classifier-api PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME classifier_api_contract
COMMAND test-classifier-api "${LW_PPOCR_C_CLS_LWM}")
add_test(
NAME c_demo_classification
COMMAND lw-classify-ppm
"${LW_PPOCR_C_CLS_LWM}"
"${LW_PPOCR_C_REC_DEMO_PPM}")
add_test(
NAME c_demo_detection
COMMAND lw-detect-ppm
"${LW_PPOCR_C_DET_LWM}"
"${LW_PPOCR_C_DET_DEMO_PPM}")
set_tests_properties(c_demo_detection PROPERTIES TIMEOUT 300)
add_test(
NAME c_demo_full_ocr
COMMAND lw-ocr-ppm
"${LW_PPOCR_C_DET_LWM}"
"${LW_PPOCR_C_CLS_LWM}"
"${LW_PPOCR_C_REC_LWM}"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
"${LW_PPOCR_C_DET_DEMO_PPM}")
set_tests_properties(c_demo_full_ocr PROPERTIES TIMEOUT 600)
add_test(
NAME c_demo_recognition
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_recognize_ppm_demo.py"
--demo "$<TARGET_FILE:lw-recognize-ppm>"
--model "${LW_PPOCR_C_REC_LWM}"
--dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--image "${LW_PPOCR_C_REC_DEMO_PPM}")
set_tests_properties(c_demo_recognition PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 180)
add_test(
NAME rec_scalar_benchmark
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_benchmark.py"
--benchmark "$<TARGET_FILE:lw-rec-benchmark>"
--model "${LW_PPOCR_C_REC_LWM}"
--dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--image "${LW_PPOCR_C_REC_DEMO_PPM}")
set_tests_properties(rec_scalar_benchmark PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 240)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(LW_FULL_OCR_BENCH_WORKERS 8)
else()
set(LW_FULL_OCR_BENCH_WORKERS 1)
endif()
add_test(
NAME full_ocr_parallel_benchmark
COMMAND lw-ocr-benchmark
"${LW_PPOCR_C_DET_LWM}"
"${LW_PPOCR_C_CLS_LWM}"
"${LW_PPOCR_C_REC_LWM}"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
"${LW_PPOCR_C_DET_DEMO_PPM}"
1 1 "${LW_FULL_OCR_BENCH_WORKERS}" 960)
set_tests_properties(full_ocr_parallel_benchmark PROPERTIES TIMEOUT 300)
if(MSVC)
get_filename_component(LW_EXPORT_TOOL_DIR "${CMAKE_C_COMPILER}" DIRECTORY)
set(LW_EXPORT_TOOL "${LW_EXPORT_TOOL_DIR}/dumpbin.exe")
else()
set(LW_EXPORT_TOOL "${CMAKE_NM}")
endif()
add_test(
NAME shared_export_contract
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_shared_exports.py"
--library "$<TARGET_FILE:lw_ppocr_c_shared>"
--allowlist "${CMAKE_CURRENT_SOURCE_DIR}/abi/exports-v0.txt"
--tool "${LW_EXPORT_TOOL}")
set_tests_properties(shared_export_contract PROPERTIES TIMEOUT 60)
add_test(
NAME shared_export_candidate_contract
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_abi_v1_candidate.py"
--header "${CMAKE_CURRENT_SOURCE_DIR}/include/lw_infer.h"
--manifest "${CMAKE_CURRENT_SOURCE_DIR}/abi/c-abi-v1-candidate.json"
--allowlist "${CMAKE_CURRENT_SOURCE_DIR}/abi/exports-v1-candidate.txt"
--library "$<TARGET_FILE:lw_ppocr_c_shared>"
--tool "${LW_EXPORT_TOOL}")
set_tests_properties(shared_export_candidate_contract PROPERTIES TIMEOUT 60)
add_executable(kernel-reference-driver tests/kernel_reference_driver.c)
target_link_libraries(kernel-reference-driver PRIVATE lw_ppocr_c)
target_include_directories(kernel-reference-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(kernel-reference-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(kernel-reference-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(kernel-reference-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME scalar_kernel_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scalar_kernels_reference.py"
--driver "$<TARGET_FILE:kernel-reference-driver>")
set_tests_properties(scalar_kernel_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_executable(tensor-reference-driver tests/tensor_reference_driver.c)
target_link_libraries(tensor-reference-driver PRIVATE lw_ppocr_c)
target_include_directories(tensor-reference-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(tensor-reference-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(tensor-reference-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(tensor-reference-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME tensor_kernel_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_tensor_kernels_reference.py"
--driver "$<TARGET_FILE:tensor-reference-driver>")
set_tests_properties(tensor_kernel_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_executable(conv-reference-driver tests/conv_reference_driver.c)
target_link_libraries(conv-reference-driver PRIVATE lw_ppocr_c)
target_include_directories(conv-reference-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(conv-reference-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(conv-reference-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(conv-reference-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME conv_kernel_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_conv_kernels_reference.py"
--driver "$<TARGET_FILE:conv-reference-driver>")
add_executable(conv3x3-benchmark-driver
tests/conv3x3_benchmark_driver.c)
target_link_libraries(conv3x3-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(conv3x3-benchmark-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(conv3x3-benchmark-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(conv3x3-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(conv3x3-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME conv3x3_benchmark_smoke
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_conv3x3_benchmark.py"
--driver "$<TARGET_FILE:conv3x3-benchmark-driver>")
set_tests_properties(conv3x3_benchmark_smoke PROPERTIES TIMEOUT 120)
add_executable(convtranspose-benchmark-driver
tests/convtranspose_benchmark_driver.c)
target_link_libraries(convtranspose-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(convtranspose-benchmark-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(convtranspose-benchmark-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(convtranspose-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(convtranspose-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME convtranspose_benchmark_smoke
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_convtranspose_benchmark.py"
--driver "$<TARGET_FILE:convtranspose-benchmark-driver>")
set_tests_properties(convtranspose_benchmark_smoke PROPERTIES TIMEOUT 120)
add_executable(packed-conv1x1-benchmark-driver
tests/packed_conv1x1_benchmark_driver.c)
target_link_libraries(packed-conv1x1-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(packed-conv1x1-benchmark-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(packed-conv1x1-benchmark-driver PRIVATE c_std_11)
if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH)
target_compile_definitions(packed-conv1x1-benchmark-driver PRIVATE LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH=1)
endif()
if(MSVC)
target_compile_options(packed-conv1x1-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(packed-conv1x1-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME packed_conv1x1_benchmark_smoke
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_packed_conv1x1_benchmark.py"
--driver "$<TARGET_FILE:packed-conv1x1-benchmark-driver>")
set_tests_properties(packed_conv1x1_benchmark_smoke PROPERTIES TIMEOUT 120)
add_executable(packed-matmul-benchmark-driver
tests/packed_matmul_benchmark_driver.c)
target_link_libraries(packed-matmul-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(packed-matmul-benchmark-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(packed-matmul-benchmark-driver PRIVATE c_std_11)
if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH)
target_compile_definitions(packed-matmul-benchmark-driver PRIVATE LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH=1)
endif()
if(MSVC)
target_compile_options(packed-matmul-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(packed-matmul-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME packed_matmul_benchmark_smoke
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_packed_matmul_benchmark.py"
--driver "$<TARGET_FILE:packed-matmul-benchmark-driver>")
set_tests_properties(packed_matmul_benchmark_smoke PROPERTIES TIMEOUT 120)
add_executable(erf-benchmark-driver
tests/erf_benchmark_driver.c)
target_link_libraries(erf-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(erf-benchmark-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(erf-benchmark-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(erf-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(erf-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME erf_benchmark_smoke
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_erf_benchmark.py"
--driver "$<TARGET_FILE:erf-benchmark-driver>")
set_tests_properties(erf_benchmark_smoke PROPERTIES TIMEOUT 120)
add_executable(conv3x3-stride2-benchmark-driver
tests/conv3x3_stride2_benchmark_driver.c)
target_link_libraries(conv3x3-stride2-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(conv3x3-stride2-benchmark-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(conv3x3-stride2-benchmark-driver PRIVATE c_std_11)
if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH)
target_compile_definitions(conv3x3-stride2-benchmark-driver PRIVATE LW_EXPERIMENTAL_AVX2_FMA_DISPATCH=1)
endif()
if(LW_AVX2_FMA_CONV3X3_DISPATCH AND NOT EMSCRIPTEN)
target_compile_definitions(conv3x3-stride2-benchmark-driver PRIVATE LW_AVX2_FMA_CONV3X3_DISPATCH=1)
endif()
if(MSVC)
target_compile_options(conv3x3-stride2-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(conv3x3-stride2-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME conv3x3_stride2_benchmark_smoke
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_conv3x3_stride2_benchmark.py"
--driver "$<TARGET_FILE:conv3x3-stride2-benchmark-driver>")
set_tests_properties(conv3x3_stride2_benchmark_smoke PROPERTIES TIMEOUT 120)
set_tests_properties(conv_kernel_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_executable(simd-backend-driver tests/simd_backend_driver.c)
target_link_libraries(simd-backend-driver PRIVATE lw_ppocr_c)
target_include_directories(simd-backend-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(simd-backend-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(simd-backend-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(simd-backend-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME simd_backend_detection COMMAND simd-backend-driver)
add_executable(rec-graph-driver tests/rec_graph_driver.c)
target_link_libraries(rec-graph-driver PRIVATE lw_ppocr_c)
target_include_directories(rec-graph-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
target_compile_features(rec-graph-driver PRIVATE c_std_11)
add_dependencies(rec-graph-driver convert_rec_model)
if(MSVC)
target_compile_definitions(rec-graph-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
target_compile_options(rec-graph-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(rec-graph-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME rec_graph_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_graph_reference.py"
--driver "$<TARGET_FILE:rec-graph-driver>"
--lwm-model "${LW_PPOCR_C_REC_LWM}"
--onnx-model "${LW_PPOCR_C_REC_ONNX}")
set_tests_properties(rec_graph_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 360)
set(LW_ONNX_WIDTH_TEST_ARGS)
if(LW_NATIVE_FINE_REC_WIDTHS)
list(APPEND LW_ONNX_WIDTH_TEST_ARGS --fine-rec-widths)
endif()
add_test(NAME native_onnx_import
COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_onnx_import.py"
--inspect "$<TARGET_FILE:lwm-inspect>"
--rec-driver "$<TARGET_FILE:rec-graph-driver>"
--ocr-driver "$<TARGET_FILE:lw-ocr-ppm>"
--root "${CMAKE_CURRENT_SOURCE_DIR}"
--sample "${LW_PPOCR_C_DET_DEMO_PPM}"
${LW_ONNX_WIDTH_TEST_ARGS}
--report "${CMAKE_CURRENT_BINARY_DIR}/onnx-import-report.json")
set_tests_properties(native_onnx_import PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 600)
add_test(NAME deployment_model_formats
COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_deployment_model_formats)
set_tests_properties(deployment_model_formats PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 120)
add_executable(cls-graph-driver tests/cls_graph_driver.c)
target_link_libraries(cls-graph-driver PRIVATE lw_ppocr_c)
target_include_directories(cls-graph-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
target_compile_features(cls-graph-driver PRIVATE c_std_11)
add_dependencies(cls-graph-driver convert_cls_model)
if(MSVC)
target_compile_options(cls-graph-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(cls-graph-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME cls_graph_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_cls_graph_reference.py"
--driver "$<TARGET_FILE:cls-graph-driver>"
--lwm-model "${LW_PPOCR_C_CLS_LWM}"
--onnx-model "${LW_PPOCR_C_CLS_ONNX}")
set_tests_properties(cls_graph_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 360)
add_executable(det-graph-driver tests/det_graph_driver.c)
target_link_libraries(det-graph-driver PRIVATE lw_ppocr_c)
target_include_directories(det-graph-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
target_compile_features(det-graph-driver PRIVATE c_std_11)
add_dependencies(det-graph-driver convert_det_model)
if(MSVC)
target_compile_definitions(det-graph-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
target_compile_options(det-graph-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(det-graph-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME det_graph_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_det_graph_reference.py"
--driver "$<TARGET_FILE:det-graph-driver>"
--lwm-model "${LW_PPOCR_C_DET_LWM}"
--onnx-model "${LW_PPOCR_C_DET_ONNX}")
set_tests_properties(det_graph_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 600)
add_executable(det-pipeline-driver tests/det_pipeline_driver.c)
target_link_libraries(det-pipeline-driver PRIVATE lw_ppocr_c)
target_include_directories(det-pipeline-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_features(det-pipeline-driver PRIVATE c_std_11)
add_dependencies(det-pipeline-driver convert_det_model)
if(MSVC)
target_compile_options(det-pipeline-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(det-pipeline-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME det_pipeline_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_det_pipeline_reference.py"
--driver "$<TARGET_FILE:det-pipeline-driver>"
--model "${LW_PPOCR_C_DET_LWM}"
--sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg")
set_tests_properties(det_pipeline_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 900)
add_executable(reading-order-driver tests/reading_order_driver.c)
target_link_libraries(reading-order-driver PRIVATE lw_ppocr_c)
target_include_directories(reading-order-driver PRIVATE src/ppocr)
target_compile_features(reading-order-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(reading-order-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(reading-order-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME reading_order_sorting COMMAND reading-order-driver)
add_executable(ocr-pipeline-driver tests/ocr_pipeline_driver.c)
target_link_libraries(ocr-pipeline-driver PRIVATE lw_ppocr_c)
target_include_directories(ocr-pipeline-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_features(ocr-pipeline-driver PRIVATE c_std_11)
add_dependencies(ocr-pipeline-driver convert_det_model convert_cls_model
convert_rec_model)
if(MSVC)
target_compile_definitions(ocr-pipeline-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
target_compile_options(ocr-pipeline-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(ocr-pipeline-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME full_ocr_pipeline_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_ocr_pipeline_reference.py"
--driver "$<TARGET_FILE:ocr-pipeline-driver>"
--detector "${LW_PPOCR_C_DET_LWM}"
--classifier "${LW_PPOCR_C_CLS_LWM}"
--recognizer "${LW_PPOCR_C_REC_LWM}"
--dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg")
set_tests_properties(full_ocr_pipeline_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 1200)
add_test(
NAME full_ocr_golden_corpus
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_ocr_golden_corpus.py"
--driver "$<TARGET_FILE:ocr-pipeline-driver>"
--detector "${LW_PPOCR_C_DET_LWM}"
--classifier "${LW_PPOCR_C_CLS_LWM}"
--recognizer "${LW_PPOCR_C_REC_LWM}"
--dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--detector-source "${LW_PPOCR_C_DET_ONNX}"
--classifier-source "${LW_PPOCR_C_CLS_ONNX}"
--recognizer-source "${LW_PPOCR_C_REC_ONNX}"
--sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
--corpus "${CMAKE_CURRENT_SOURCE_DIR}/tests/fixtures/ocr-golden-corpus.json")
set_tests_properties(full_ocr_golden_corpus PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 1200)
add_executable(cls-pipeline-driver tests/cls_pipeline_driver.c)
target_link_libraries(cls-pipeline-driver PRIVATE lw_ppocr_c)
if(WIN32)
target_link_libraries(cls-pipeline-driver PRIVATE shell32)
endif()
target_include_directories(cls-pipeline-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_features(cls-pipeline-driver PRIVATE c_std_11)
add_dependencies(cls-pipeline-driver convert_cls_model)
if(MSVC)
target_compile_options(cls-pipeline-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(cls-pipeline-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME cls_pipeline_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_cls_pipeline_reference.py"
--driver "$<TARGET_FILE:cls-pipeline-driver>"
--lwm-model "${LW_PPOCR_C_CLS_LWM}"
--onnx-model "${LW_PPOCR_C_CLS_ONNX}")
set_tests_properties(cls_pipeline_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 360)
add_executable(rec-profile-driver tests/rec_profile_driver.c)
target_link_libraries(rec-profile-driver PRIVATE lw_ppocr_c)
target_include_directories(rec-profile-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
target_compile_features(rec-profile-driver PRIVATE c_std_11)
add_dependencies(rec-profile-driver convert_rec_model)
if(MSVC)
target_compile_options(rec-profile-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(rec-profile-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME rec_operator_profile
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_profile.py"
--driver "$<TARGET_FILE:rec-profile-driver>"
--model "${LW_PPOCR_C_REC_LWM}")
set_tests_properties(rec_operator_profile PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 240)
add_executable(full-ocr-profile-driver tests/full_ocr_profile_driver.c)
target_link_libraries(full-ocr-profile-driver PRIVATE lw_ppocr_c)
target_include_directories(full-ocr-profile-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/examples"
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_features(full-ocr-profile-driver PRIVATE c_std_11)
add_dependencies(full-ocr-profile-driver convert_det_model convert_cls_model
convert_rec_model det_demo_fixture)
if(MSVC)
target_compile_options(full-ocr-profile-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(full-ocr-profile-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
set(full_ocr_profile_test_args
--driver "$<TARGET_FILE:full-ocr-profile-driver>"
--det-model "${LW_PPOCR_C_DET_LWM}"
--cls-model "${LW_PPOCR_C_CLS_LWM}"
--rec-model "${LW_PPOCR_C_REC_LWM}"
--dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--image "${LW_PPOCR_C_DET_DEMO_PPM}")
if(LW_REC_RESIDENT_WIDTHS AND NOT EMSCRIPTEN)
list(APPEND full_ocr_profile_test_args --expect-resident)
endif()
if(LW_X64_REC_FAST_ENABLED)
list(APPEND full_ocr_profile_test_args --expect-compiled-rec)
endif()
if(LW_EXPERIMENTAL_PREPARED_EXECUTION AND NOT EMSCRIPTEN)
list(APPEND full_ocr_profile_test_args --expect-prepared)
endif()
add_test(
NAME full_ocr_operator_profile
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_full_ocr_profile.py"
${full_ocr_profile_test_args})
set_tests_properties(full_ocr_operator_profile PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 360)
# Test-only benchmark variant: it links the static runtime so an internal
# DET intra-op override can be measured without expanding the public ABI.
add_executable(full-ocr-intra-benchmark examples/ocr_benchmark_ppm.c)
target_link_libraries(full-ocr-intra-benchmark PRIVATE lw_ppocr_c)
target_compile_definitions(full-ocr-intra-benchmark PRIVATE
LW_OCR_BENCHMARK_INTERNAL=1)
target_include_directories(full-ocr-intra-benchmark PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/examples"
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr"
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(full-ocr-intra-benchmark PRIVATE c_std_11)
add_dependencies(full-ocr-intra-benchmark convert_det_model convert_cls_model
convert_rec_model det_demo_fixture)
if(WIN32)
target_link_libraries(full-ocr-intra-benchmark PRIVATE shell32 psapi)
endif()
if(MSVC)
target_compile_options(full-ocr-intra-benchmark PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(full-ocr-intra-benchmark PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
# Same-process dataset benchmark used to measure resident/compact memory
# and latency without restarting the OCR runtime for every image.
if(NOT EMSCRIPTEN)
add_executable(full-ocr-dataset-benchmark examples/ocr_dataset_benchmark.c)
target_link_libraries(full-ocr-dataset-benchmark PRIVATE lw_ppocr_c)
target_include_directories(full-ocr-dataset-benchmark PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/examples"
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(full-ocr-dataset-benchmark PRIVATE c_std_11)
add_dependencies(full-ocr-dataset-benchmark convert_det_model convert_cls_model
convert_rec_model det_demo_fixture)
if(LW_REC_RESIDENT_WIDTHS)
target_compile_definitions(full-ocr-dataset-benchmark PRIVATE LW_REC_RESIDENT_WIDTHS=1)
endif()
if(WIN32)
target_link_libraries(full-ocr-dataset-benchmark PRIVATE shell32 psapi)
endif()
if(MSVC)
target_compile_definitions(full-ocr-dataset-benchmark PRIVATE _CRT_SECURE_NO_WARNINGS)
target_compile_options(full-ocr-dataset-benchmark PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(full-ocr-dataset-benchmark PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
if(LW_X64_REC_FAST_ENABLED AND LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET)
add_test(
NAME full_ocr_adaptive_rec_budget
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_ocr_adaptive_rec_budget.py"
--benchmark "$<TARGET_FILE:full-ocr-dataset-benchmark>"
--det "${LW_PPOCR_C_DET_LWM}"
--cls "${LW_PPOCR_C_CLS_LWM}"
--rec "${LW_PPOCR_C_REC_LWM}"
--dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--sample "${LW_PPOCR_C_DET_DEMO_PPM}")
set_tests_properties(full_ocr_adaptive_rec_budget PROPERTIES TIMEOUT 180)
endif()
endif()
add_executable(rec-preprocess-layout-driver tests/rec_preprocess_layout_driver.c)
target_link_libraries(rec-preprocess-layout-driver PRIVATE lw_ppocr_c)
target_include_directories(rec-preprocess-layout-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_features(rec-preprocess-layout-driver PRIVATE c_std_11)
if(MSVC)
target_compile_definitions(rec-preprocess-layout-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
target_compile_options(rec-preprocess-layout-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(rec-preprocess-layout-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME rec_preprocess_layout COMMAND rec-preprocess-layout-driver)
set_tests_properties(rec_preprocess_layout PROPERTIES TIMEOUT 30)
add_executable(nhwc-conv1x1-driver tests/nhwc_conv1x1_driver.c)
target_link_libraries(nhwc-conv1x1-driver PRIVATE lw_ppocr_c)
target_include_directories(nhwc-conv1x1-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(nhwc-conv1x1-driver PRIVATE c_std_11)
if(MSVC AND CMAKE_SYSTEM_PROCESSOR MATCHES "(AMD64|x86_64|amd64|X86)")
target_compile_options(nhwc-conv1x1-driver PRIVATE /arch:AVX2)
endif()
if(MSVC)
target_compile_definitions(nhwc-conv1x1-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
target_compile_options(nhwc-conv1x1-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(nhwc-conv1x1-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME nhwc_conv1x1_layout COMMAND nhwc-conv1x1-driver)
set_tests_properties(nhwc_conv1x1_layout PROPERTIES TIMEOUT 30)
if(LW_EXPERIMENTAL_AVX2_FAST_PATH AND
(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|amd64|AMD64|x64|X86)$" OR
MSVC_C_ARCHITECTURE_ID MATCHES "^(x64|X86)$"))
add_executable(nhwc-pointwise-benchmark-driver
tests/nhwc_pointwise_driver.c
src/kernels/nhwc_pack.c
src/simd/avx2_nhwc_pointwise.c)
target_link_libraries(nhwc-pointwise-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(nhwc-pointwise-benchmark-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(nhwc-pointwise-benchmark-driver PRIVATE c_std_11)
target_compile_definitions(nhwc-pointwise-benchmark-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
if(MSVC)
set_property(SOURCE src/simd/avx2_nhwc_pointwise.c APPEND PROPERTY
COMPILE_OPTIONS /arch:AVX2 /fp:strict)
target_compile_definitions(nhwc-pointwise-benchmark-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(nhwc-pointwise-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(nhwc-pointwise-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME nhwc_pointwise_benchmark
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_nhwc_pointwise_benchmark.py"
--driver "$<TARGET_FILE:nhwc-pointwise-benchmark-driver>")
set_tests_properties(nhwc_pointwise_benchmark PROPERTIES TIMEOUT 120)
add_executable(nhwc-support-driver
tests/nhwc_support_driver.c)
target_link_libraries(nhwc-support-driver PRIVATE lw_ppocr_c)
target_include_directories(nhwc-support-driver PRIVATE
src/kernels)
target_compile_features(nhwc-support-driver PRIVATE c_std_11)
target_compile_definitions(nhwc-support-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
if(MSVC)
target_compile_definitions(nhwc-support-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(nhwc-support-driver PRIVATE /arch:AVX2 /W4 /WX /utf-8)
else()
target_compile_options(nhwc-support-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME nhwc_support_pool COMMAND nhwc-support-driver)
set_tests_properties(nhwc_support_pool PROPERTIES TIMEOUT 30)
add_executable(nhwc-dense-benchmark-driver
tests/nhwc_dense_driver.c
src/kernels/nhwc_pack.c
src/simd/avx2_nhwc_dense.c)
target_link_libraries(nhwc-dense-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(nhwc-dense-benchmark-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(nhwc-dense-benchmark-driver PRIVATE c_std_11)
target_compile_definitions(nhwc-dense-benchmark-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
if(MSVC)
set_property(SOURCE src/simd/avx2_nhwc_dense.c APPEND PROPERTY
COMPILE_OPTIONS /arch:AVX2 /fp:strict)
target_compile_definitions(nhwc-dense-benchmark-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(nhwc-dense-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(nhwc-dense-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME nhwc_dense_benchmark
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_nhwc_dense_benchmark.py"
--driver "$<TARGET_FILE:nhwc-dense-benchmark-driver>")
set_tests_properties(nhwc_dense_benchmark PROPERTIES TIMEOUT 120)
add_executable(nhwc-convtranspose-driver
tests/nhwc_convtranspose_driver.c)
target_link_libraries(nhwc-convtranspose-driver PRIVATE lw_ppocr_c)
target_include_directories(nhwc-convtranspose-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
"${CMAKE_CURRENT_SOURCE_DIR}/src/simd"
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
target_compile_features(nhwc-convtranspose-driver PRIVATE c_std_11)
target_compile_definitions(nhwc-convtranspose-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
if(MSVC)
target_compile_definitions(nhwc-convtranspose-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(nhwc-convtranspose-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(nhwc-convtranspose-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME nhwc_convtranspose_contract COMMAND nhwc-convtranspose-driver)
set_tests_properties(nhwc_convtranspose_contract PROPERTIES TIMEOUT 120)
add_executable(x64-rec-backend-contract-driver
tests/x64_rec_backend_contract_driver.c)
target_link_libraries(x64-rec-backend-contract-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-rec-backend-contract-driver PRIVATE
src/runtime
src/kernels
src/simd)
target_compile_features(x64-rec-backend-contract-driver PRIVATE c_std_11)
target_compile_definitions(x64-rec-backend-contract-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-rec-backend-contract-driver convert_rec_model)
if(MSVC)
target_compile_definitions(x64-rec-backend-contract-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-rec-backend-contract-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-rec-backend-contract-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_rec_backend_contract
COMMAND x64-rec-backend-contract-driver ${LW_PPOCR_C_REC_LWM})
set_tests_properties(x64_rec_backend_contract PROPERTIES TIMEOUT 120)
add_executable(x64-rec-backend-execution-driver
tests/x64_rec_backend_execution_driver.c)
if(LW_EXPERIMENTAL_REC_FFN_TILING)
add_executable(rec-ffn-contract-driver tests/rec_ffn_contract_driver.c)
target_link_libraries(rec-ffn-contract-driver PRIVATE lw_ppocr_c)
target_include_directories(rec-ffn-contract-driver PRIVATE src/runtime src/kernels src/simd)
target_compile_features(rec-ffn-contract-driver PRIVATE c_std_11)
if(MSVC)
target_compile_options(rec-ffn-contract-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(rec-ffn-contract-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()
foreach(variant tiny small medium)
add_test(NAME rec_ffn_contract_${variant}
COMMAND rec-ffn-contract-driver
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-${variant}/rec.onnx")
set_tests_properties(rec_ffn_contract_${variant} PROPERTIES TIMEOUT 180)
endforeach()
endif()
target_link_libraries(x64-rec-backend-execution-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-rec-backend-execution-driver PRIVATE
src/runtime
src/kernels
src/simd
src/ppocr)
target_compile_features(x64-rec-backend-execution-driver PRIVATE c_std_11)
target_compile_definitions(x64-rec-backend-execution-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-rec-backend-execution-driver convert_rec_model)
if(MSVC)
target_compile_definitions(x64-rec-backend-execution-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-rec-backend-execution-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-rec-backend-execution-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_rec_backend_execution
COMMAND x64-rec-backend-execution-driver ${LW_PPOCR_C_REC_LWM})
set_tests_properties(x64_rec_backend_execution PROPERTIES TIMEOUT 120)
add_executable(x64-rec-shared-constants-driver
tests/x64_rec_shared_constants_driver.c)
target_link_libraries(x64-rec-shared-constants-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-rec-shared-constants-driver PRIVATE
src/runtime src/kernels src/simd)
target_compile_features(x64-rec-shared-constants-driver PRIVATE c_std_11)
add_dependencies(x64-rec-shared-constants-driver convert_rec_model)
if(MSVC)
target_compile_options(x64-rec-shared-constants-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-rec-shared-constants-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_rec_shared_constants
COMMAND x64-rec-shared-constants-driver ${LW_PPOCR_C_REC_LWM})
set_tests_properties(x64_rec_shared_constants PROPERTIES TIMEOUT 120)
add_executable(x64-rec-backend-nchw-driver
tests/x64_rec_backend_nchw_driver.c)
target_link_libraries(x64-rec-backend-nchw-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-rec-backend-nchw-driver PRIVATE
src/runtime
src/kernels
src/simd
src/ppocr)
target_compile_features(x64-rec-backend-nchw-driver PRIVATE c_std_11)
target_compile_definitions(x64-rec-backend-nchw-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-rec-backend-nchw-driver convert_rec_model)
if(MSVC)
target_compile_definitions(x64-rec-backend-nchw-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-rec-backend-nchw-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-rec-backend-nchw-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_rec_backend_nchw
COMMAND x64-rec-backend-nchw-driver ${LW_PPOCR_C_REC_LWM})
set_tests_properties(x64_rec_backend_nchw PROPERTIES TIMEOUT 120)
add_executable(x64-rec-layout-benchmark-driver
tests/x64_rec_layout_benchmark_driver.c)
target_link_libraries(x64-rec-layout-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-rec-layout-benchmark-driver PRIVATE
src/runtime
src/kernels
src/simd
src/ppocr)
target_compile_features(x64-rec-layout-benchmark-driver PRIVATE c_std_11)
target_compile_definitions(x64-rec-layout-benchmark-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-rec-layout-benchmark-driver convert_rec_model)
if(MSVC)
target_compile_definitions(x64-rec-layout-benchmark-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-rec-layout-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-rec-layout-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_rec_layout_benchmark
COMMAND x64-rec-layout-benchmark-driver ${LW_PPOCR_C_REC_LWM} 5)
set_tests_properties(x64_rec_layout_benchmark PROPERTIES TIMEOUT 120)
foreach(rec_width IN ITEMS 192 320 480 640)
add_test(NAME x64_rec_layout_benchmark_${rec_width}
COMMAND x64-rec-layout-benchmark-driver ${LW_PPOCR_C_REC_LWM}
5 ${rec_width})
set_tests_properties(x64_rec_layout_benchmark_${rec_width}
PROPERTIES TIMEOUT 120)
endforeach()
add_executable(x64-det-backend-contract-driver
tests/x64_det_backend_contract_driver.c)
target_link_libraries(x64-det-backend-contract-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-det-backend-contract-driver PRIVATE
src/runtime
src/kernels
src/simd
src/ppocr)
target_compile_features(x64-det-backend-contract-driver PRIVATE c_std_11)
target_compile_definitions(x64-det-backend-contract-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-det-backend-contract-driver convert_det_model)
if(MSVC)
target_compile_definitions(x64-det-backend-contract-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-det-backend-contract-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-det-backend-contract-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_det_backend_contract
COMMAND x64-det-backend-contract-driver ${LW_PPOCR_C_DET_LWM} 32 64)
set_tests_properties(x64_det_backend_contract PROPERTIES TIMEOUT 120)
add_test(NAME x64_det_backend_contract_sharded
COMMAND x64-det-backend-contract-driver ${LW_PPOCR_C_DET_LWM} 640 640)
set_tests_properties(x64_det_backend_contract_sharded PROPERTIES TIMEOUT 180)
add_executable(x64-det-layout-benchmark-driver
tests/x64_det_layout_benchmark_driver.c)
target_link_libraries(x64-det-layout-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-det-layout-benchmark-driver PRIVATE
src/runtime
src/kernels
src/simd
src/ppocr)
target_compile_features(x64-det-layout-benchmark-driver PRIVATE c_std_11)
target_compile_definitions(x64-det-layout-benchmark-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-det-layout-benchmark-driver convert_det_model)
if(MSVC)
target_compile_definitions(x64-det-layout-benchmark-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-det-layout-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-det-layout-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_det_layout_benchmark
COMMAND x64-det-layout-benchmark-driver ${LW_PPOCR_C_DET_LWM} 32 64 1 3)
set_tests_properties(x64_det_layout_benchmark PROPERTIES TIMEOUT 120)
add_executable(x64-rec-backend-benchmark-driver
tests/x64_rec_backend_benchmark_driver.c)
target_link_libraries(x64-rec-backend-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-rec-backend-benchmark-driver PRIVATE
src/runtime
src/kernels
src/simd
src/ppocr)
target_compile_features(x64-rec-backend-benchmark-driver PRIVATE c_std_11)
target_compile_definitions(x64-rec-backend-benchmark-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-rec-backend-benchmark-driver convert_rec_model)
if(MSVC)
target_compile_definitions(x64-rec-backend-benchmark-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-rec-backend-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-rec-backend-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_rec_backend_benchmark
COMMAND x64-rec-backend-benchmark-driver ${LW_PPOCR_C_REC_LWM} 5)
set_tests_properties(x64_rec_backend_benchmark PROPERTIES TIMEOUT 120)
add_test(NAME x64_rec_backend_benchmark_nchw
COMMAND x64-rec-backend-benchmark-driver ${LW_PPOCR_C_REC_LWM} 5 nchw)
set_tests_properties(x64_rec_backend_benchmark_nchw PROPERTIES TIMEOUT 120)
add_executable(x64-rec-recognizer-benchmark-driver
tests/x64_rec_recognizer_benchmark_driver.c)
target_link_libraries(x64-rec-recognizer-benchmark-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-rec-recognizer-benchmark-driver PRIVATE
src/ppocr)
target_compile_features(x64-rec-recognizer-benchmark-driver PRIVATE c_std_11)
target_compile_definitions(x64-rec-recognizer-benchmark-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-rec-recognizer-benchmark-driver convert_rec_model)
if(MSVC)
target_compile_definitions(x64-rec-recognizer-benchmark-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-rec-recognizer-benchmark-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-rec-recognizer-benchmark-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_rec_recognizer_benchmark
COMMAND x64-rec-recognizer-benchmark-driver ${LW_PPOCR_C_REC_LWM}
${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt 5)
foreach(rec_width IN ITEMS 192 320 480 640)
add_test(NAME x64_rec_recognizer_benchmark_${rec_width}
COMMAND x64-rec-recognizer-benchmark-driver ${LW_PPOCR_C_REC_LWM}
${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt
5 ${rec_width})
set_tests_properties(x64_rec_recognizer_benchmark_${rec_width}
PROPERTIES TIMEOUT 120)
endforeach()
set_tests_properties(x64_rec_recognizer_benchmark PROPERTIES TIMEOUT 120)
add_executable(x64-rec-pointwise-layout-driver
tests/x64_rec_pointwise_layout_driver.c)
target_link_libraries(x64-rec-pointwise-layout-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-rec-pointwise-layout-driver PRIVATE
src/runtime
src/kernels
src/simd)
target_compile_features(x64-rec-pointwise-layout-driver PRIVATE c_std_11)
target_compile_definitions(x64-rec-pointwise-layout-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-rec-pointwise-layout-driver convert_rec_model)
if(MSVC)
target_compile_definitions(x64-rec-pointwise-layout-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-rec-pointwise-layout-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-rec-pointwise-layout-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_rec_pointwise_layout
COMMAND x64-rec-pointwise-layout-driver ${LW_PPOCR_C_REC_LWM} 5)
set_tests_properties(x64_rec_pointwise_layout PROPERTIES TIMEOUT 120)
add_executable(x64-rec-pointwise-tuning-driver
tests/x64_rec_pointwise_tuning_driver.c)
target_link_libraries(x64-rec-pointwise-tuning-driver PRIVATE lw_ppocr_c)
target_include_directories(x64-rec-pointwise-tuning-driver PRIVATE
src/runtime
src/kernels
src/simd
src/ppocr)
target_compile_features(x64-rec-pointwise-tuning-driver PRIVATE c_std_11)
target_compile_definitions(x64-rec-pointwise-tuning-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(x64-rec-pointwise-tuning-driver convert_rec_model)
if(MSVC)
target_compile_definitions(x64-rec-pointwise-tuning-driver PRIVATE
_CRT_SECURE_NO_WARNINGS)
target_compile_options(x64-rec-pointwise-tuning-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(x64-rec-pointwise-tuning-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_executable(rec-fast-prototype-driver tests/rec_fast_prototype_driver.c)
target_link_libraries(rec-fast-prototype-driver PRIVATE lw_ppocr_c)
target_include_directories(rec-fast-prototype-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
"${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
target_compile_features(rec-fast-prototype-driver PRIVATE c_std_11)
target_compile_definitions(rec-fast-prototype-driver PRIVATE
LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
add_dependencies(rec-fast-prototype-driver convert_rec_model)
if(MSVC)
target_compile_definitions(rec-fast-prototype-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
target_compile_options(rec-fast-prototype-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(rec-fast-prototype-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(NAME x64_rec_fast_prototype
COMMAND rec-fast-prototype-driver "${LW_PPOCR_C_REC_LWM}" 960)
set_tests_properties(x64_rec_fast_prototype PROPERTIES TIMEOUT 120)
elseif(LW_EXPERIMENTAL_AVX2_FAST_PATH)
message(WARNING
"LW_EXPERIMENTAL_AVX2_FAST_PATH requires an x86/x64 build; benchmark target skipped")
endif()
add_executable(rec-pipeline-driver tests/rec_pipeline_driver.c)
target_link_libraries(rec-pipeline-driver PRIVATE lw_ppocr_c)
if(WIN32)
target_link_libraries(rec-pipeline-driver PRIVATE shell32)
endif()
target_include_directories(rec-pipeline-driver PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
"${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
target_compile_features(rec-pipeline-driver PRIVATE c_std_11)
add_dependencies(rec-pipeline-driver convert_rec_model)
if(MSVC)
target_compile_definitions(rec-pipeline-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
target_compile_options(rec-pipeline-driver PRIVATE /W4 /WX /utf-8)
else()
target_compile_options(rec-pipeline-driver PRIVATE
-Wall -Wextra -Wpedantic -Werror)
endif()
add_test(
NAME rec_pipeline_reference
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_pipeline_reference.py"
--driver "$<TARGET_FILE:rec-pipeline-driver>"
--lwm-model "${LW_PPOCR_C_REC_LWM}"
--onnx-model "${LW_PPOCR_C_REC_ONNX}"
--dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg")
set_tests_properties(rec_pipeline_reference PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 360)
add_test(
NAME rec_golden_corpus
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_golden_corpus.py"
--driver "$<TARGET_FILE:rec-pipeline-driver>"
--lwm-model "${LW_PPOCR_C_REC_LWM}"
--onnx-model "${LW_PPOCR_C_REC_ONNX}"
--dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
--sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
--corpus "${CMAKE_CURRENT_SOURCE_DIR}/tests/fixtures/rec-golden-corpus.json")
set_tests_properties(rec_golden_corpus PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
TIMEOUT 600)
add_test(
NAME lwm_corruption
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_lwm_corruption.py"
--inspect "$<TARGET_FILE:lwm-inspect>"
--model "${LW_PPOCR_C_REC_LWM}")
set_tests_properties(lwm_corruption PROPERTIES
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
if(LW_BUILD_HTTP_DEMO)
add_test(
NAME http_demo_smoke
COMMAND "${Python3_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/tests/test_http_demo.py"
--server "$<TARGET_FILE:lw-http-ocr>"
--models "${CMAKE_CURRENT_BINARY_DIR}/models"
--www "${CMAKE_CURRENT_BINARY_DIR}/www"
--sample "${LW_PPOCR_C_DET_DEMO_PPM}")
set_tests_properties(http_demo_smoke PROPERTIES TIMEOUT 120)
endif()
endif()
if(MSVC)
set(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION "${CMAKE_INSTALL_BINDIR}")
set(CMAKE_INSTALL_UCRT_LIBRARIES TRUE)
include(InstallRequiredSystemLibraries)
endif()
if(NOT EMSCRIPTEN)
install(TARGETS lw_ppocr_c lw_ppocr_c_shared
EXPORT lw.PPOCR.CTargets
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
install(TARGETS lw-recognize-ppm lw-rec-benchmark lw-ocr-benchmark lw-classify-ppm lw-detect-ppm
lw-ocr-ppm
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
install(FILES include/lw_infer.h
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
install(FILES
examples/CMakeLists.txt
examples/classify_ppm.c
examples/detect_ppm.c
examples/ocr_ppm.c
examples/abi_v1_client.c
examples/ppm_image.h
examples/recognize_ppm.c
DESTINATION examples)
install(DIRECTORY
examples/csharp-common
examples/csharp-winforms
examples/http-server
examples/java-jni
DESTINATION examples
PATTERN "bin" EXCLUDE
PATTERN "obj" EXCLUDE)
install(FILES
"${LW_PPOCR_C_REC_LWM}"
"${LW_PPOCR_C_CLS_LWM}"
"${LW_PPOCR_C_DET_LWM}"
"${LW_PPOCR_C_REC_ONNX}" "${LW_PPOCR_C_CLS_ONNX}" "${LW_PPOCR_C_DET_ONNX}"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/model.json"
"${LW_PPOCR_C_REC_DEMO_PPM}"
"${LW_PPOCR_C_DET_DEMO_PPM}"
"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
DESTINATION models)
endif()
if(LW_BUILD_CSHARP_DEMOS)
install(FILES
"${LW_MANAGED_WINFORMS_EXE}"
"${LW_MANAGED_WINFORMS_EXE}.config"
DESTINATION "${CMAKE_INSTALL_BINDIR}")
endif()
if(LW_BUILD_HTTP_DEMO)
install(TARGETS lw-http-ocr
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
install(DIRECTORY examples/http-server/www/
DESTINATION www)
endif()
install(DIRECTORY docs/
DESTINATION docs
FILES_MATCHING
PATTERN "*.md"
PATTERN "*.jpg")
install(FILES
abi/c-abi-v1-candidate.json
abi/runtime-contract-v1.json
abi/c-abi-v1-layout.json
abi/lwm-v0.1-layout.json
abi/web-abi-v1-candidate.json
abi/exports-v1-candidate.txt
DESTINATION docs/abi)
install(FILES
README.md
README.zh-CN.md
LICENSE
THIRD-PARTY-NOTICES.md
dependencies.lock.json
sbom.cdx.json
DESTINATION .)
install(FILES
ci/stable-release-scope.json
DESTINATION ci)
if(LW_BUILD_ENVIRONMENT_FILE)
if(NOT EXISTS "${LW_BUILD_ENVIRONMENT_FILE}")
message(FATAL_ERROR
"LW_BUILD_ENVIRONMENT_FILE does not exist: ${LW_BUILD_ENVIRONMENT_FILE}")
endif()
install(FILES "${LW_BUILD_ENVIRONMENT_FILE}"
DESTINATION .
RENAME BUILD-ENVIRONMENT.txt)
endif()
install(FILES
licenses/PaddleOCR-models-APACHE-2.0.txt
licenses/cpp-httplib-MIT.txt
DESTINATION licenses)
if(NOT EMSCRIPTEN)
set(LW_CMAKE_PACKAGE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/lw.PPOCR.C")
configure_package_config_file(
cmake/lw.PPOCR.CConfig.cmake.in
"${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.CConfig.cmake"
INSTALL_DESTINATION "${LW_CMAKE_PACKAGE_DIR}")
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.CConfigVersion.cmake"
VERSION "${PROJECT_VERSION}"
COMPATIBILITY SameMajorVersion)
install(EXPORT lw.PPOCR.CTargets
FILE lw.PPOCR.CTargets.cmake
NAMESPACE lw.PPOCR.C::
DESTINATION "${LW_CMAKE_PACKAGE_DIR}")
install(FILES
"${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.CConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.CConfigVersion.cmake"
DESTINATION "${LW_CMAKE_PACKAGE_DIR}")
endif()
if(BUILD_TESTING AND NOT EMSCRIPTEN)
add_test(
NAME staged_package
COMMAND "${CMAKE_COMMAND}"
-DLW_BUILD_DIR=${CMAKE_CURRENT_BINARY_DIR}
-DLW_STAGE_DIR=${CMAKE_CURRENT_BINARY_DIR}/stage-test
-DLW_CONFIG=$<CONFIG>
-DLW_GENERATOR=${CMAKE_GENERATOR}
-DLW_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
-DLW_C_COMPILER=${CMAKE_C_COMPILER}
-DLW_RC_COMPILER=${CMAKE_RC_COMPILER}
-DLW_MT=${CMAKE_MT}
-DLW_PYTHON=${Python3_EXECUTABLE}
-DLW_TEST_SCRIPT=${CMAKE_CURRENT_SOURCE_DIR}/tests/test_staged_package.py
-DLW_HTTP_TEST_SCRIPT=${CMAKE_CURRENT_SOURCE_DIR}/tests/test_http_demo.py
-DLW_HTTP_TEST_REQUEST_TIMEOUT=${LW_HTTP_TEST_REQUEST_TIMEOUT}
-DLW_HTTP_TEST_PROCESS_TIMEOUT=${LW_HTTP_TEST_PROCESS_TIMEOUT}
-P "${CMAKE_CURRENT_SOURCE_DIR}/tests/run_staged_package_test.cmake")
set_tests_properties(staged_package PROPERTIES
TIMEOUT "${LW_STAGED_PACKAGE_TEST_TIMEOUT}")
endif()
if(LW_PACKAGE_PLATFORM_OVERRIDE)
set(LW_PACKAGE_PLATFORM "${LW_PACKAGE_PLATFORM_OVERRIDE}")
if(WIN32)
set(CPACK_GENERATOR ZIP)
else()
set(CPACK_GENERATOR TGZ)
endif()
elseif(WIN32)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(LW_PACKAGE_PLATFORM windows-x64-msvc)
else()
set(LW_PACKAGE_PLATFORM windows-x86-msvc)
endif()
set(CPACK_GENERATOR ZIP)
else()
string(TOLOWER "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}"
LW_PACKAGE_PLATFORM)
set(CPACK_GENERATOR TGZ)
endif()
set(CPACK_PACKAGE_NAME "lw.PPOCR.C")
set(CPACK_PACKAGE_VENDOR "天天代码码天天")
set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
set(CPACK_PACKAGE_FILE_NAME
"lw.PPOCR.C-${PROJECT_VERSION}-${LW_PACKAGE_PLATFORM}")
set(CPACK_PACKAGE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/packages")
set(CPACK_PACKAGE_CHECKSUM SHA256)
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
include(CPack)