commit d05e08940f3604036294b22f75840948e673fdac · pyrox.dev/nixpkgs

+50 -13

pkgs/development/libraries/opencv/4.x.nix

···

       15
       15
        
       , ocl-icd

     

       16
       16
        
       , buildPackages

     

       17
       17
        
       , qimgv

     

       18
       18
       +
       , opencv4

     

       18
       19
        
       

     

       19
       20
        
       , enableJPEG ? true

     

       20
       21
        
       , libjpeg

     
···

       31
       32
        
       , openjpeg

     

       32
       33
        
       , enableEigen ? true

     

       33
       34
        
       , eigen

     

       34
       34
       -
       , enableOpenblas ? true

     

       35
       35
       -
       , openblas

     

       35
       35
       +
       , enableBlas ? true

     

       36
       36
       +
       , blas

     

       36
       37
        
       , enableContrib ? true

     

       37
       38
        
       

     

       38
       39
        
       , enableCuda ? (config.cudaSupport or false) && stdenv.hostPlatform.isx86_64

     
···

       74
       75
        
       , CoreMedia

     

       75
       76
        
       , MediaToolbox

     

       76
       77
        
       , bzip2

     

       78
       78
       +
       , callPackage

     

       77
       79
        
       }:

     

       78
       80
        
       

     

       79
       81
        
       let

     
···

       93
       95
        
           sha256 = "sha256-meya0J3RdOIeMM46e/6IOVwrKn3t/c0rhwP2WQaybkE=";

     

       94
       96
        
         };

     

       95
       97
        
       

     

       98
       98
       +
         testDataSrc = fetchFromGitHub {

     

       99
       99
       +
           owner = "opencv";

     

       100
       100
       +
           repo = "opencv_extra";

     

       101
       101
       +
           rev = version;

     

       102
       102
       +
           sha256 = "sha256-6hAdJdaUgtRGQanQKuY/q6fcXWXFZ3K/oLbGxvksry0=";

     

       103
       103
       +
         };

     

       104
       104
       +
       

     

       96
       105
        
         # Contrib must be built in order to enable Tesseract support:

     

       97
       106
        
         buildContrib = enableContrib || enableTesseract || enableOvis;

     

       98
       107
        
       

     
···

       171
       180
        
         ade = rec {

     

       172
       181
        
           src = fetchurl {

     

       173
       182
        
             url = "https://github.com/opencv/ade/archive/${name}";

     

       174
       174
       -
             sha256 = "04n9na2bph706bdxnnqfcbga4cyj8kd9s9ni7qyvnpj5v98jwvlm";

     

       183
       183
       +
             sha256 = "sha256-TjLRbFbC7MDY9PxIy560ryviBI58cbQwqgc7A7uOHkg=";

     

       175
       184
        
           };

     

       176
       176
       -
           name = "v0.1.1f.zip";

     

       177
       177
       -
           md5 = "b624b995ec9c439cbc2e9e6ee940d3a2";

     

       185
       185
       +
           name = "v0.1.2a.zip";

     

       186
       186
       +
           md5 = "fa4b3e25167319cb0fa9432ef8281945";

     

       178
       187
        
           dst = ".cache/ade";

     

       179
       188
        
         };

     

       180
       189
        
       

     
···

       208
       217
        
       

     

       209
       218
        
         opencvFlag = name: enabled: "-DWITH_${name}=${printEnabled enabled}";

     

       210
       219
        
       

     

       220
       220
       +
         runAccuracyTests = true;

     

       221
       221
       +
         runPerformanceTests = false;

     

       211
       222
        
         printEnabled = enabled: if enabled then "ON" else "OFF";

     

       223
       223
       +
         withOpenblas = (enableBlas && blas.provider.pname == "openblas");

     

       224
       224
       +
         #multithreaded openblas conflicts with opencv multithreading, which manifest itself in hung tests

     

       225
       225
       +
         #https://github.com/xianyi/OpenBLAS/wiki/Faq/4bded95e8dc8aadc70ce65267d1093ca7bdefc4c#multi-threaded

     

       226
       226
       +
         openblas_ = blas.provider.override { singleThreaded = true; };

     

       212
       227
        
       in

     

       213
       228
        
       

     

       214
       229
        
       stdenv.mkDerivation {

     

       215
       230
        
         pname = "opencv";

     

       216
       231
        
         inherit version src;

     

       232
       232
       +
       

     

       233
       233
       +
         outputs = [

     

       234
       234
       +
           "out"

     

       235
       235
       +
           "package_tests"

     

       236
       236
       +
         ];

     

       217
       237
        
       

     

       218
       238
        
         postUnpack = lib.optionalString buildContrib ''

     

       219
       239
        
           cp --no-preserve=mode -r "${contribSrc}/modules" "$NIX_BUILD_TOP/source/opencv_contrib"

     
···

       263
       283
        
           ++ lib.optional enableFfmpeg ffmpeg

     

       264
       284
        
           ++ lib.optionals (enableFfmpeg && stdenv.isDarwin)

     

       265
       285
        
             [ VideoDecodeAcceleration bzip2 ]

     

       266
       266
       -
           ++ lib.optionals enableGStreamer (with gst_all_1; [ gstreamer gst-plugins-base ])

     

       286
       286
       +
           ++ lib.optionals enableGStreamer (with gst_all_1; [ gstreamer gst-plugins-base gst-plugins-good ])

     

       267
       287
        
           ++ lib.optional enableOvis ogre

     

       268
       288
        
           ++ lib.optional enableGPhoto2 libgphoto2

     

       269
       289
        
           ++ lib.optional enableDC1394 libdc1394

     

       270
       290
        
           ++ lib.optional enableEigen eigen

     

       271
       271
       -
           ++ lib.optional enableOpenblas openblas

     

       291
       291
       +
           ++ lib.optional enableBlas blas.provider

     

       272
       292
        
           # There is seemingly no compile-time flag for Tesseract.  It's

     

       273
       293
        
           # simply enabled automatically if contrib is built, and it detects

     

       274
       294
        
           # tesseract & leptonica.

     
···

       290
       310
        
         NIX_CFLAGS_COMPILE = lib.optionalString enableEXR "-I${ilmbase.dev}/include/OpenEXR";

     

       291
       311
        
       

     

       292
       312
        
         # Configure can't find the library without this.

     

       293
       293
       -
         OpenBLAS_HOME = lib.optionalString enableOpenblas openblas;

     

       313
       313
       +
         OpenBLAS_HOME = lib.optionalString withOpenblas openblas_.dev;

     

       314
       314
       +
         OpenBLAS = lib.optionalString withOpenblas openblas_;

     

       294
       315
        
       

     

       295
       316
        
         cmakeFlags = [

     

       296
       317
        
           "-DOPENCV_GENERATE_PKGCONFIG=ON"

     
···

       299
       320
        
           "-DProtobuf_PROTOC_EXECUTABLE=${lib.getExe buildPackages.protobuf}"

     

       300
       321
        
           "-DPROTOBUF_UPDATE_FILES=ON"

     

       301
       322
        
           "-DOPENCV_ENABLE_NONFREE=${printEnabled enableUnfree}"

     

       302
       302
       -
           "-DBUILD_TESTS=OFF"

     

       303
       303
       -
           "-DBUILD_PERF_TESTS=OFF"

     

       323
       323
       +
           "-DBUILD_TESTS=${printEnabled runAccuracyTests}"

     

       324
       324
       +
           "-DBUILD_PERF_TESTS=${printEnabled runPerformanceTests}"

     

       325
       325
       +
           "-DCMAKE_SKIP_BUILD_RPATH=ON"

     

       304
       326
        
           "-DBUILD_DOCS=${printEnabled enableDocs}"

     

       305
       327
        
           # "OpenCV disables pkg-config to avoid using of host libraries. Consider using PKG_CONFIG_LIBDIR to specify target SYSROOT"

     

       306
       328
        
           # but we have proper separation of build and host libs :), fixes cross

     
···

       334
       356
        
           make doxygen

     

       335
       357
        
         '';

     

       336
       358
        
       

     

       359
       359
       +
         preInstall =

     

       360
       360
       +
           lib.optionalString (runAccuracyTests || runPerformanceTests) ''

     

       361
       361
       +
           mkdir $package_tests

     

       362
       362
       +
           cp -R $src/samples $package_tests/

     

       363
       363
       +
           ''

     

       364
       364
       +
           + lib.optionalString runAccuracyTests "mv ./bin/*test* $package_tests/ \n"

     

       365
       365
       +
           + lib.optionalString runPerformanceTests "mv ./bin/*perf* $package_tests/";

     

       366
       366
       +
       

     

       337
       367
        
         # By default $out/lib/pkgconfig/opencv4.pc looks something like this:

     

       338
       368
        
         #

     

       339
       369
        
         #   prefix=/nix/store/g0wnfyjjh4rikkvp22cpkh41naa43i4i-opencv-4.0.0

     
···

       368
       398
        
       

     

       369
       399
        
         passthru = {

     

       370
       400
        
           tests = {

     

       371
       371
       -
             inherit qimgv;

     

       372
       401
        
             inherit (gst_all_1) gst-plugins-bad;

     

       373
       373
       -
           } // lib.optionalAttrs (!enablePython) { pythonEnabled = pythonPackages.opencv4; };

     

       402
       402
       +
           }

     

       403
       403
       +
           // lib.optionalAttrs (!stdenv.isDarwin) { inherit qimgv; }

     

       404
       404
       +
           // lib.optionalAttrs (!enablePython) { pythonEnabled = pythonPackages.opencv4; }

     

       405
       405
       +
           // lib.optionalAttrs (stdenv.buildPlatform != "x86_64-darwin") {

     

       406
       406
       +
             opencv4-tests = callPackage ./tests.nix {

     

       407
       407
       +
               inherit enableGStreamer enableGtk2 enableGtk3 runAccuracyTests runPerformanceTests testDataSrc;

     

       408
       408
       +
               inherit opencv4;

     

       409
       409
       +
               };

     

       410
       410
       +
             };

     

       374
       411
        
         } // lib.optionalAttrs enablePython { pythonPath = [ ]; };

     

       375
       412
        
       

     

       376
       413
        
         meta = with lib; {

     

       377
       414
        
           description = "Open Computer Vision Library with more than 500 algorithms";

     

       378
       415
        
           homepage = "https://opencv.org/";

     

       379
       416
        
           license = with licenses; if enableUnfree then unfree else bsd3;

     

       380
       380
       -
           maintainers = with maintainers; [ mdaiter basvandijk ];

     

       417
       417
       +
           maintainers = with maintainers; [ basvandijk ];

     

       381
       418
        
           platforms = with platforms; linux ++ darwin;

     

       382
       419
        
         };

     

       383
       420
        
       }

+70

pkgs/development/libraries/opencv/tests.nix

···

       1
       1
       +
       { opencv4

     

       2
       2
       +
       , testDataSrc

     

       3
       3
       +
       , stdenv

     

       4
       4
       +
       , lib

     

       5
       5
       +
       , runCommand

     

       6
       6
       +
       , gst_all_1

     

       7
       7
       +
       , runAccuracyTests

     

       8
       8
       +
       , runPerformanceTests

     

       9
       9
       +
       , enableGStreamer

     

       10
       10
       +
       , enableGtk2

     

       11
       11
       +
       , enableGtk3

     

       12
       12
       +
       , xvfb-run

     

       13
       13
       +
       }:

     

       14
       14
       +
       let

     

       15
       15
       +
         testNames = [

     

       16
       16
       +
           "calib3d"

     

       17
       17
       +
           "core"

     

       18
       18
       +
           "features2d"

     

       19
       19
       +
           "flann"

     

       20
       20
       +
           "imgcodecs"

     

       21
       21
       +
           "imgproc"

     

       22
       22
       +
           "ml"

     

       23
       23
       +
           "objdetect"

     

       24
       24
       +
           "photo"

     

       25
       25
       +
           "stitching"

     

       26
       26
       +
           "video"

     

       27
       27
       +
           #"videoio" # - a lot of GStreamer warnings and failed tests

     

       28
       28
       +
           #"dnn" #- some caffe tests failed, probably because github workflow also downloads additional models

     

       29
       29
       +
         ] ++ lib.optionals (!stdenv.isAarch64 && enableGStreamer) [ "gapi" ]

     

       30
       30
       +
         ++ lib.optionals (enableGtk2 || enableGtk3) [ "highgui" ];

     

       31
       31
       +
         perfTestNames = [

     

       32
       32
       +
           "calib3d"

     

       33
       33
       +
           "core"

     

       34
       34
       +
           "features2d"

     

       35
       35
       +
           "imgcodecs"

     

       36
       36
       +
           "imgproc"

     

       37
       37
       +
           "objdetect"

     

       38
       38
       +
           "photo"

     

       39
       39
       +
           "stitching"

     

       40
       40
       +
           "video"

     

       41
       41
       +
         ] ++ lib.optionals (!stdenv.isAarch64 && enableGStreamer) [ "gapi" ];

     

       42
       42
       +
         testRunner = if stdenv.isDarwin then "" else "${lib.getExe xvfb-run} -a ";

     

       43
       43
       +
         testsPreparation = ''

     

       44
       44
       +
           touch $out

     

       45
       45
       +
           # several tests want a write access, so we have to copy files

     

       46
       46
       +
           tmpPath="$(mktemp -d "/tmp/opencv_extra_XXXXXX")"

     

       47
       47
       +
           cp -R ${testDataSrc} $tmpPath/opencv_extra

     

       48
       48
       +
           chmod -R +w $tmpPath/opencv_extra

     

       49
       49
       +
           export OPENCV_TEST_DATA_PATH="$tmpPath/opencv_extra/testdata"

     

       50
       50
       +
           export OPENCV_SAMPLES_DATA_PATH="${opencv4.package_tests}/samples/data"

     

       51
       51
       +
       

     

       52
       52
       +
           #ignored tests because of gtest error - "Test code is not available due to compilation error with GCC 11"

     

       53
       53
       +
           export GTEST_FILTER="-AsyncAPICancelation/cancel*"

     

       54
       54
       +
         '';

     

       55
       55
       +
         accuracyTests = lib.optionalString runAccuracyTests ''

     

       56
       56
       +
           ${ builtins.concatStringsSep "\n"

     

       57
       57
       +
             (map (test: "${testRunner}${opencv4.package_tests}/opencv_test_${test} --test_threads=$NIX_BUILD_CORES --gtest_filter=$GTEST_FILTER" ) testNames)

     

       58
       58
       +
           }

     

       59
       59
       +
         '';

     

       60
       60
       +
         perfomanceTests = lib.optionalString runPerformanceTests ''

     

       61
       61
       +
           ${ builtins.concatStringsSep "\n"

     

       62
       62
       +
             (map (test: "${testRunner}${opencv4.package_tests}/opencv_perf_${test} --perf_impl=plain --perf_min_samples=10 --perf_force_samples=10 --perf_verify_sanity --skip_unstable=1 --gtest_filter=$GTEST_FILTER") perfTestNames)

     

       63
       63
       +
           }

     

       64
       64
       +
         '';

     

       65
       65
       +
       in

     

       66
       66
       +
       runCommand "opencv4-tests"

     

       67
       67
       +
       {

     

       68
       68
       +
         nativeBuildInputs = lib.optionals enableGStreamer (with gst_all_1; [ gstreamer gst-plugins-base gst-plugins-good ]);

     

       69
       69
       +
       }

     

       70
       70
       +
         (testsPreparation + accuracyTests + perfomanceTests)