Recherche avancée

Sur d’autres sites (10553)

• Show progress of a video conversion with c# (see details please)

  25 février 2015, par ChrisCreateBoss

  I’m using WinForms. I want to show the progress of a video conversion, I’m currently using the NReco.VideoConverter, I’ve tried FFLib.Encoder too, it has an EventHandler named Progress, but I can’t make it work with the progressBar.

  I’ve tried progressBar1.Value += converter.Progress;, also tried using a "percentHandler", and it failed.

  Hope someone can help me. Also, if someone knows about a better video conversion library, please let me know.

  Thnaks in advance

• Cannot read xvid video with opencv in python on mac

  15 février 2017, par crazjo

  I have been trying for hours to read a xvid .avi file on my mac with python 2.7 and opencv. I have installed all the latest versions using brew and opencv is working in python and I can open images and other movie files but when I try to read a xvid avi file with

  cap.cv2.VideoCapture('video.AVI')
  
  ret, frame = cap.read()

  It fails as frame is empty. I have installed ffmpeg with brew and x264 as well and ran brew doctor. I am totally lost what to do now. Happy to provide more information if needed. I hope someone can help me, thanks.

• issue after video rotation how fix

  2 avril 2015, par Vahagn

  I have next code for rotate video

  OpenCVFrameConverter.ToIplImage converter2 = new OpenCVFrameConverter.ToIplImage() ;

  for (int i = firstIndex; i <= lastIndex; i++) {
  
      long t = timestamps[i % timestamps.length] - startTime;
  
      if (t >= 0) {
  
          if (t > recorder.getTimestamp()) {
  
              recorder.setTimestamp(t);
  
          }
  
          Frame g = converter2.convert(rotate(converter2.convertToIplImage(images[i % images.length]),9 0));
  
      recorder.record(g);
  
      }
  
  }

  images[i] - Frame in JavaCV
  after in video have green lines

  

  UPDATE
  Convertation function

  /*
  
   * Copyright (C) 2015 Samuel Audet
  
   *
  
   * This file is part of JavaCV.
  
   *
  
   * JavaCV is free software: you can redistribute it and/or modify
  
   * it under the terms of the GNU General Public License as published by
  
   * the Free Software Foundation, either version 2 of the License, or
  
   * (at your option) any later version (subject to the "Classpath" exception
  
   * as provided in the LICENSE.txt file that accompanied this code).
  
   *
  
   * JavaCV is distributed in the hope that it will be useful,
  
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  
   * GNU General Public License for more details.
  
   *
  
   * You should have received a copy of the GNU General Public License
  
   * along with JavaCV.  If not, see /www.gnu.org/licenses/>.
  
   */
  
  
  
  package com.example.vvardanyan.ffmpeg;
  
  
  
  import org.bytedeco.javacpp.BytePointer;
  
  import org.bytedeco.javacpp.Pointer;
  
  
  
  import java.nio.Buffer;
  
  
  
  import static org.bytedeco.javacpp.opencv_core.CV_16S;
  
  import static org.bytedeco.javacpp.opencv_core.CV_16U;
  
  import static org.bytedeco.javacpp.opencv_core.CV_32F;
  
  import static org.bytedeco.javacpp.opencv_core.CV_32S;
  
  import static org.bytedeco.javacpp.opencv_core.CV_64F;
  
  import static org.bytedeco.javacpp.opencv_core.CV_8S;
  
  import static org.bytedeco.javacpp.opencv_core.CV_8U;
  
  import static org.bytedeco.javacpp.opencv_core.CV_MAKETYPE;
  
  import static org.bytedeco.javacpp.opencv_core.IPL_DEPTH_16S;
  
  import static org.bytedeco.javacpp.opencv_core.IPL_DEPTH_16U;
  
  import static org.bytedeco.javacpp.opencv_core.IPL_DEPTH_32F;
  
  import static org.bytedeco.javacpp.opencv_core.IPL_DEPTH_32S;
  
  import static org.bytedeco.javacpp.opencv_core.IPL_DEPTH_64F;
  
  import static org.bytedeco.javacpp.opencv_core.IPL_DEPTH_8S;
  
  import static org.bytedeco.javacpp.opencv_core.IPL_DEPTH_8U;
  
  import static org.bytedeco.javacpp.opencv_core.IplImage;
  
  import static org.bytedeco.javacpp.opencv_core.Mat;
  
  
  
  /**
  
   * A utility class to map data between {@link Frame} and {@link IplImage} or {@link Mat}.
  
   * Since this is an abstract class, one must choose between two concrete classes:
  
   * {@link ToIplImage} or {@link ToMat}.
  
   *
  
   * @author Samuel Audet
  
   */
  
  public abstract class OpenCVFrameConverter<f> extends FrameConverter<f> {
  
      IplImage img;
  
      Mat mat;
  
  
  
      public static class ToIplImage extends OpenCVFrameConverter<iplimage> {
  
          @Override public IplImage convert(Frame frame) { return convertToIplImage(frame); }
  
      }
  
  
  
      public static class ToMat extends OpenCVFrameConverter<mat> {
  
          @Override public Mat convert(Frame frame) { return convertToMat(frame); }
  
      }
  
  
  
      public static int getFrameDepth(int depth) {
  
          switch (depth) {
  
              case IPL_DEPTH_8U:  case CV_8U:  return Frame.DEPTH_UBYTE;
  
              case IPL_DEPTH_8S:  case CV_8S:  return Frame.DEPTH_BYTE;
  
              case IPL_DEPTH_16U: case CV_16U: return Frame.DEPTH_USHORT;
  
              case IPL_DEPTH_16S: case CV_16S: return Frame.DEPTH_SHORT;
  
              case IPL_DEPTH_32F: case CV_32F: return Frame.DEPTH_FLOAT;
  
              case IPL_DEPTH_32S: case CV_32S: return Frame.DEPTH_INT;
  
              case IPL_DEPTH_64F: case CV_64F: return Frame.DEPTH_DOUBLE;
  
              default: return -1;
  
          }
  
      }
  
  
  
      public static int getIplImageDepth(Frame frame) {
  
          switch (frame.imageDepth) {
  
              case Frame.DEPTH_UBYTE:  return IPL_DEPTH_8U;
  
              case Frame.DEPTH_BYTE:   return IPL_DEPTH_8S;
  
              case Frame.DEPTH_USHORT: return IPL_DEPTH_16U;
  
              case Frame.DEPTH_SHORT:  return IPL_DEPTH_16S;
  
              case Frame.DEPTH_FLOAT:  return IPL_DEPTH_32F;
  
              case Frame.DEPTH_INT:    return IPL_DEPTH_32S;
  
              case Frame.DEPTH_DOUBLE: return IPL_DEPTH_64F;
  
              default:  return -1;
  
          }
  
      }
  
      static boolean isEqual(Frame frame, IplImage img) {
  
          return img != null &amp;&amp; frame != null &amp;&amp; frame.image != null &amp;&amp; frame.image.length > 0
  
                  &amp;&amp; frame.imageWidth == img.width() &amp;&amp; frame.imageHeight == img.height()
  
                  &amp;&amp; frame.imageChannels == img.nChannels() &amp;&amp; getIplImageDepth(frame) == img.depth()
  
                  &amp;&amp; new Pointer(frame.image[0]).address() == img.imageData().address()
  
                  &amp;&amp; frame.imageStride * Math.abs(frame.imageDepth) / 8 == img.widthStep();
  
      }
  
      public IplImage convertToIplImage(Frame frame) {
  
          if (frame == null) {
  
              return null;
  
          } else if (frame.opaque instanceof IplImage) {
  
              return (IplImage)frame.opaque;
  
          } else if (!isEqual(frame, img)) {
  
              int depth = getIplImageDepth(frame);
  
              img = depth &lt; 0 ? null : IplImage.createHeader(frame.imageWidth, frame.imageHeight, depth, frame.imageChannels)
  
                      .imageData(new BytePointer(new Pointer(frame.image[0].position(0)))).widthStep(frame.imageStride * Math.abs(frame.imageDepth) / 8);
  
          }
  
          return img;
  
      }
  
      public Frame convert(IplImage img) {
  
          if (img == null) {
  
              return null;
  
          } else if (!isEqual(frame, img)) {
  
              frame = new Frame();
  
              frame.imageWidth = img.width();
  
              frame.imageHeight = img.height();
  
              frame.imageDepth = getFrameDepth(img.depth());
  
              frame.imageChannels = img.nChannels();
  
              frame.imageStride = img.widthStep() * 8 / Math.abs(frame.imageDepth);
  
              frame.image = new Buffer[] { img.createBuffer() };
  
              frame.opaque = img;
  
          }
  
          return frame;
  
      }
  
  
  
      public static int getMatDepth(Frame frame) {
  
          switch (frame.imageDepth) {
  
              case Frame.DEPTH_UBYTE:  return CV_8U;
  
              case Frame.DEPTH_BYTE:   return CV_8S;
  
              case Frame.DEPTH_USHORT: return CV_16U;
  
              case Frame.DEPTH_SHORT:  return CV_16S;
  
              case Frame.DEPTH_FLOAT:  return CV_32F;
  
              case Frame.DEPTH_INT:    return CV_32S;
  
              case Frame.DEPTH_DOUBLE: return CV_64F;
  
              default:  return -1;
  
          }
  
      }
  
      static boolean isEqual(Frame frame, Mat mat) {
  
          return mat != null &amp;&amp; frame != null &amp;&amp; frame.image != null &amp;&amp; frame.image.length > 0
  
                  &amp;&amp; frame.imageWidth == mat.cols() &amp;&amp; frame.imageHeight == mat.rows()
  
                  &amp;&amp; frame.imageChannels == mat.channels() &amp;&amp; getMatDepth(frame) == mat.depth()
  
                  &amp;&amp; new Pointer(frame.image[0]).address() == mat.data().address()
  
                  &amp;&amp; frame.imageStride * Math.abs(frame.imageDepth) / 8 == (int)mat.step();
  
      }
  
      public Mat convertToMat(Frame frame) {
  
          if (frame == null) {
  
              return null;
  
          } else if (frame.opaque instanceof Mat) {
  
              return (Mat)frame.opaque;
  
          } else if (!isEqual(frame, mat)) {
  
              int depth = getMatDepth(frame);
  
              mat = depth &lt; 0 ? null : new Mat(frame.imageHeight, frame.imageWidth, CV_MAKETYPE(depth, frame.imageChannels),
  
                      new Pointer(frame.image[0].position(0)), frame.imageStride * Math.abs(frame.imageDepth) / 8);
  
          }
  
          return mat;
  
      }
  
      public Frame convert(Mat mat) {
  
          if (mat == null) {
  
              return null;
  
          } else if (!isEqual(frame, mat)) {
  
              frame = new Frame();
  
              frame.imageWidth = mat.cols();
  
              frame.imageHeight = mat.rows();
  
              frame.imageDepth = getFrameDepth(mat.depth());
  
              frame.imageChannels = mat.channels();
  
              frame.imageStride = (int)mat.step() * 8 / Math.abs(frame.imageDepth);
  
              frame.image = new Buffer[] { mat.createBuffer() };
  
              frame.opaque = mat;
  
          }
  
          return frame;
  
      }
  
  }
  
  </mat></iplimage></f></f>