使用ImageMagick有效地将线扫描图像拼接在一起

时间：2018-09-30 18:16:46

标签： ffmpeg computer-vision imagemagick gige-sdk

我正在寻找用于运动计时或需要弄清楚放置位置的线扫描相机的替代方案。我发现普通的工业相机可以轻松地以超过每秒1000帧的速度与商用相机解决方案匹敌。对于我的需求，通常计时的准确性并不重要，但是运动员的相对位置。我以为我可以使用最便宜的Basler，IDS或任何其他区域扫描工业相机之一。当然，有些行扫描相机的速度可以超过数千fps（或hz），但是有可能获得面积扫描相机以不到500€的速度完成1000-3000fps的工作。

我的圣杯当然是FinishLynx（或任何其他线扫描系统）的近实时图像合成功能，基本上这部分是：https://youtu.be/7CWZvFcwSEk?t=23s

我一直在寻找替代方案的整个过程是：

  
      
  • 使用Basler Pylon Viewer（或其他软件）以相机最快的读取速度记录2px宽的图像。对于相机，我是   当前正在使用它意味着必须将其打开，并且   高度需要降低，因为这是它将读取的唯一方法    1920x2px 帧@> 250fps
    •   
  • 制作程序或批处理脚本，然后将这些 1920x2px 帧拼接在一起，例如，录制 1000 * 1920x2px 的一秒钟   帧，即分辨率为 1920x2000px 的结果图像   （水平x垂直）。
    •   
  • 最后使用相同的程序或其他方式，只需旋转图像以反映相机的位置，从而获得图像   分辨率为 2000x1920px （再次为水平x垂直）
    •   
  • 在分析程序（当前为ImageJ）中打开图像以快速分析结果
    •   

我不是程序员，但这当然是我在使用stackoverflow的帮助下，仅使用批处理脚本就能将其组合在一起的。

  
      
  • 当前，例如可以将整个10秒钟以原始/ mjpeg（avi / mkv）流的形式实时记录到磁盘上。
    •   
  • 将单个帧记录为TIFF或BMP，或使用FFMPEG将其保存为PNG或JPG大约需要20-60秒   然后再花费约45-60秒   这一切都需要在不到60秒的时间内完成10秒的镜头（1000-3000fps @ 10s = 10000-30000帧），因此为什么我需要更快的东西。
    •   

我能够弄清楚ImageMagick的效率如何：

magick convert -limit file 16384 -limit memory 8GiB -interlace Plane -quality 85 -append +rotate 270 “%folder%\Basler*.Tiff” “%out%”

#%out% has a .jpg -filename that is dynamically made from folder name and number of frames.

此命令有效，并在i5-2520m上约30秒内获得10000帧编码（尽管大多数处理似乎仅使用一个线程，因为它以25％的CPU使用率工作）。这是生成的图像：https://i.imgur.com/OD4RqL7.jpg（19686x1928px）

但是，由于使用Basler的Pylon Viewer录制到TIFF帧所需的时间比录制MJPEG视频流所需的时间长得多，因此我想将MJPEG（avi / mkv）文件用作附加源。我注意到FFMPEG具有“ image2pipe”命令，该命令应能够直接将图像提供给ImageMagick。我却无法使它工作：

   $ ffmpeg.exe -threads 4 -y -i "Basler acA1920-155uc (21644989)_20180930_043754312.avi" -f image2pipe - | convert - -interlace Plane -quality 85 -append +rotate 270 "%out%" >> log.txt
    ffmpeg version 3.4 Copyright (c) 2000-2017 the FFmpeg developers
      built with gcc 7.2.0 (GCC)
      configuration: –enable-gpl –enable-version3 –enable-sdl2 –enable-bzlib –enable-fontconfig –enable-gnutls –enable-iconv –enable-libass –enable-libbluray –enable-libfreetype –enable-libmp3lame –enable-libopenjpeg –enable-libopus –enable-libshine –enable-libsnappy –enable-libsoxr –enable-libtheora –enable-libtwolame –enable-libvpx –enable-libwavpack –enable-libwebp –enable-libx264 –enable-libx265 –enable-libxml2 –enable-libzimg –enable-lzma –enable-zlib –enable-gmp –enable-libvidstab –enable-libvorbis –enable-cuda –enable-cuvid –enable-d3d11va –enable-nvenc –enable-dxva2 –enable-avisynth –enable-libmfx
      libavutil      55. 78.100 / 55. 78.100
      libavcodec     57.107.100 / 57.107.100
      libavformat    57. 83.100 / 57. 83.100
      libavdevice    57. 10.100 / 57. 10.100
      libavfilter     6.107.100 /  6.107.100
      libswscale      4.  8.100 /  4.  8.100
      libswresample   2.  9.100 /  2.  9.100
      libpostproc    54.  7.100 / 54.  7.100
    Invalid Parameter - -interlace
    [mjpeg @ 000000000046b0a0] EOI missing, emulating
    Input #0, avi, from 'Basler acA1920-155uc (21644989)_20180930_043754312.avi’:
      Duration: 00:00:50.02, start: 0.000000, bitrate: 1356 kb/s
        Stream #0:0: Video: mjpeg (MJPG / 0x47504A4D), yuvj422p(pc, bt470bg/unknown/unknown), 1920x2, 1318 kb/s, 200 fps, 200 tbr, 200 tbn, 200 tbc
    Stream mapping:
      Stream #0:0 -> #0:0 (mjpeg (native) -> mjpeg (native))
    Press [q] to stop, [?] for help
    Output #0, image2pipe, to ‘pipe:’:
      Metadata:
        encoder         : Lavf57.83.100
        Stream #0:0: Video: mjpeg, yuvj422p(pc), 1920x2, q=2-31, 200 kb/s, 200 fps, 200 tbn, 200 tbc
        Metadata:
          encoder         : Lavc57.107.100 mjpeg
        Side data:
          cpb: bitrate max/min/avg: 0/0/200000 buffer size: 0 vbv_delay: -1
    av_interleaved_write_frame(): Invalid argument
    Error writing trailer of pipe:: Invalid argument
    frame=    1 fps=0.0 q=1.6 Lsize=       0kB time=00:00:00.01 bitrate= 358.4kbits/s speed=0.625x
    video:0kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.000000%
    Conversion failed!

如果我将身高提高一点，我将不再遇到“ [mjpeg @ 000000000046b0a0] EOI丢失，模拟”的错误。但是，整个操作仅适用于<2px高/宽素材。

edit：哦，是的，我也可以使用ffmpeg -i file.mpg -r 1/1 $filename%03d.bmp或ffmpeg -i file.mpg $filename%03d.bmp从MJPEG / RAW流中提取所有帧。但是，这是我不想采取的额外步骤。 （仅删除30000个jpg的文件夹就需要2分钟的时间…）

有人能想到管道方法的可行解决方案或完全不同的替代方法吗？

2 个答案:

答案 0 :(得分：3)

我生成了10,000帧的样本视频，并进行了一些测试。显然，我的机器与您的机器规格不同，因此结果无法直接比较，但是我发现让ffmpeg转置视频并将其原始传输到 ImageMagick RGB24帧。

我发现我可以像这样在10.3秒钟内将10秒的电影转换成20,000x1920像素的JPEG：

ffmpeg -threads 4 -y -i video.mov -frames 10000 -vf "transpose=1" -f image2pipe -vcodec rawvideo -pix_fmt rgb24 - | convert -depth 8 -size 2x1920 rgb:- +append result.jpg

结果图像如下：

enter image description here

我用CImg生成了这样的视频。基本上，它只是在框架上依次画一个红色/绿色/蓝色色块，直到它碰到右边缘，然后从左边缘再次开始：

#include <iostream>
#include "CImg.h"

using namespace std;
using namespace cimg_library;

int main()
{
   // Frame we will fill
   CImg<unsigned char> frame(1920,2,1,3);

   int width =frame.width();
   int height=frame.height();

   // Item to draw in frame - created with ImageMagick
   // convert xc:red xc:lime xc:blue +append -resize 256x2\! splodge.ppm
   CImg<unsigned char> splodge("splodge.ppm");

   int offs  =0;

   // We are going to output 10000 frames of RGB raw video
   for(int f=0;f<10000;f++){
      // Generate white image
      frame.fill(255);

      // Draw coloured splodge at correct place
      frame.draw_image(offs,0,splodge);
      offs = (offs + 1) % (width - splodge.width());

      // Output to ffmpeg to make video, in planar GBR format
      // i.e. run program like this
      // ./main | ffmpeg -y -f rawvideo -pixel_format gbrp -video_size 1920x2 -i - -c:v h264 -pix_fmt yuv420p video.mov
      char* s=reinterpret_cast<char*>(frame.data()+(width*height));   // Get start of G plane
      std::cout.write(s,width*height);                                // Output it
      s=reinterpret_cast<char*>(frame.data()+2*(width*height));       // Get start of B plane
      std::cout.write(s,width*height);                                // Output it
      s=reinterpret_cast<char*>(frame.data());                        // Get start of R plane
      std::cout.write(s,width*height);                                // Output it
   }
}

splodge是192x2像素，看起来像这样：

enter image description here

答案 1 :(得分：3)

我还想知道我是否可以通过几种不同的方式来加快我的其他答案的速度-因此得出了不同的答案。我使用了在其他答案中生成的相同的合成视频剪辑进行测试。

我没有将2x1920扫描线传递到 ImageMagick 以便附加在一起并以JPEG格式编写，而是执行了以下操作：

  • 在C ++程序中先创建完整的输出帧，然后在每次迭代中循环读取2x1920扫描线，并将其填充到输出帧中的正确位置，然后

  • 在读取了整个序列后，使用turbo-jpeg将其压缩为JPEG并将其写入磁盘。

因此，不再需要 ImageMagick 。现在，整个程序的运行时间约为1.3秒，而不是通过 ImageMagick 的10.3秒运行。

代码如下：

////////////////////////////////////////////////////////////////////////////////
// stitch.cpp
// Mark Setchell
//
// Read 2x1920 RGB frames from `ffmpeg` and stitch into 20000x1920 RGB image.
////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <unistd.h>
#include <turbojpeg.h>

using namespace std;

int main()
{
   int frames = 10000;
   int height = 1920;
   int width  = frames *2;

   // Buffer in which to assemble complete output image (RGB), e.g. 20000x1920
   unsigned char *img = new unsigned char [width*height*3];

   // Buffer for one scanline image 1920x2 (RGB)
   unsigned char *scanline = new unsigned char[2*height*3];

   // Output column
   int ocol=0;

   // Read frames from `ffmpeg` fed into us like this:
   // ffmpeg -threads 4 -y -i video.mov -frames 10000 -vf "transpose=1" -f image2pipe -vcodec rawvideo -pix_fmt rgb24 - | ./stitch
   for(int f=0;f<10000;f++){
      // Read one scanline from stdin, i.e. 2x1920 RGB image...
      ssize_t bytesread = read(STDIN_FILENO, scanline, 2*height*3);

      // ... and place into finished frame
      // ip is pointer to input image
      unsigned char *ip = scanline;
      for(int row=0;row<height;row++){
         unsigned char *op = &(img[(row*width*3)+3*ocol]);
         // Copy 2 RGB pixels from scanline to output image
         *op++ = *ip++; // red
         *op++ = *ip++; // green
         *op++ = *ip++; // blue
         *op++ = *ip++; // red
         *op++ = *ip++; // green
         *op++ = *ip++; // blue
      }
      ocol += 2; 
   }

   // Now encode to JPEG with turbo-jpeg
   const int JPEG_QUALITY = 75;
   long unsigned int jpegSize = 0;
   unsigned char* compressedImage = NULL;
   tjhandle _jpegCompressor = tjInitCompress();

   // Compress in memory
   tjCompress2(_jpegCompressor, img, width, 0, height, TJPF_RGB,
          &compressedImage, &jpegSize, TJSAMP_444, JPEG_QUALITY,
          TJFLAG_FASTDCT);

   // Clean up
   tjDestroy(_jpegCompressor);

   // And write to disk
   ofstream f("result.jpg", ios::out | ios::binary);
   f.write (reinterpret_cast<char*>(compressedImage), jpegSize);
}

注释：

注意1：为了预先分配输出图像，程序需要提前知道要多少帧-我没有进行参数设置，我只是硬编码10,000，但是它应该足够容易更改。

一种确定视频序列中帧数的方法是：

ffprobe -v error -count_frames -select_streams v:0 -show_entries stream=nb_frames -of default=nokey=1:noprint_wrappers=1 video.mov

注意2：注意，我使用几个开关来编译代码以提高性能：

g++-8 -O3 -march=native stitch.cpp -o stitch

注意3：：如果您在Windows上运行，则可能需要先以二进制模式重新打开stdin，然后再执行以下操作：

read(STDIN_FILENO...)

注意4：：如果您不想使用turbo-jpeg，则可以在主循环结束后删除所有内容，而只需发送NetPBM {{1} }图像通过管道传输到 ImageMagick ，并使其进行JPEG写入。大概看起来像这样：

PPM

然后您将使用：

writeToStdout("P6 20000 1920 255\n");
writeToStdout(img, width*height*3);
相关问题
最新问题