Can't convert to image from /camera/image/compressed

edit

When I've worked with compressed image topics, I've never had to deal with the compressed data directly I've left that to the image_transport package. You can use the following code to setup a subscriber, this will work with the compressed topic if it is available, or with an uncompressed one if that's all that's available.

image_transport::ImageTransport it(n);
itSub = it.subscribe("topic_name", 1, imageCallbackFn, image_transport::TransportHints("compressed"));

Then your imageCallbackFn will be the same as a regular image callback because the decompression is being handled for you:

// Image callback
void imageCallbackFn(const sensor_msgs::ImageConstPtr& msg)
{
  cv_bridge::CvImagePtr cvImg = cv_bridge::toCvCopy(msg, "bgr8");
  cv::Mat myOpenCVImg = cvImg->image;
}

Hope this helps you get this working.

ImageTransport doesn't work for all purposes (for example a message filters sync subscriber between a CompressedImage and anything other than a CameraInfo), and likewise with a separate republish node for decompression, so if you want to do the decompression yourself call toCvCopy on it in a callback that subscribes directly to a CompressedImage:

void MyNode::compressedImageCallback(
    const sensor_msgs::CompressedImageConstPtr& image_msg)
{
  const std::string encoding = "bgr8";
  cv_bridge::CvImageConstPtr cv_ptr;
  try
  { 
    cv_ptr = cv_bridge::toCvCopy(image_msg, encoding);
  }
  catch (cv_bridge::Exception& e)
  {
    ROS_ERROR("cv_bridge exception: %s", e.what());
    return;
 }
...

The toCvCopy that converts the compressed image (cutting and paste code in to improve searchability here):

CvImagePtr toCvCopy(const sensor_msgs::CompressedImage& source, const std::string& encoding)
{
  // Construct matrix pointing to source data
  const cv::Mat_<uchar> in(1, source.data.size(), const_cast<uchar*>(&source.data[0]));
  // Loads as BGR or BGRA.
  const cv::Mat rgb_a = cv::imdecode(in, cv::IMREAD_UNCHANGED);

  if (encoding != enc::MONO16) {
    switch (rgb_a.channels())
    {
      case 4:
        return toCvCopyImpl(rgb_a, source.header, enc::BGRA8, encoding);
        break;
      case 3:
        return toCvCopyImpl(rgb_a, source.header, enc::BGR8, encoding);
        break;
      case 1:
        return toCvCopyImpl(rgb_a, source.header, enc::MONO8, encoding);
        break;
      default:
        return CvImagePtr();
    }
  }
  else {
    return toCvCopyImpl(rgb_a, source.header, enc::MONO16, encoding);
  }
}

https://github.com/ros-perception/vis...

There's another implementation here:

void CompressedSubscriber::internalCallback(const sensor_msgs::CompressedImageConstPtr& message,
                                            const Callback& user_cb)

{

  cv_bridge::CvImagePtr cv_ptr(new cv_bridge::CvImage);

  // Copy message header
  cv_ptr->header = message->header;

  // Decode color/mono image
  try
  {
    cv_ptr->image = cv::imdecode(cv::Mat(message->data), imdecode_flag_);

    // Assign image encoding string
    const size_t split_pos = message->format.find(';');
    if (split_pos==std::string::npos)
    {
      // Older version of compressed_image_transport does not signal image format
      switch (cv_ptr->image.channels())
      {
        case 1:
          cv_ptr->encoding = enc::MONO8;
          break;
        case 3:
          cv_ptr->encoding = enc::BGR8;
          break;
        default:
          ROS_ERROR("Unsupported number of channels: %i", cv_ptr->image.channels());
          break;
      }
    } else
    {
      std::string image_encoding = message->format.substr(0, split_pos);

      cv_ptr->encoding = image_encoding;

      if ( enc::isColor(image_encoding))
      {
        std::string compressed_encoding = message->format.substr(split_pos);
        bool compressed_bgr_image = (compressed_encoding.find("compressed bgr") != std::string::npos);

        // Revert color transformation
        if (compressed_bgr_image)
        {
          // if necessary convert colors from bgr to rgb
          if ((image_encoding == enc::RGB8) || (image_encoding == enc::RGB16))
            cv::cvtColor(cv_ptr->image, cv_ptr->image, CV_BGR2RGB);

          if ((image_encoding == enc::RGBA8) || (image_encoding == enc::RGBA16))
            cv::cvtColor(cv_ptr->image, cv_ptr->image, CV_BGR2RGBA);

          if ((image_encoding == enc::BGRA8) || (image_encoding == enc::BGRA16))
            cv::cvtColor(cv_ptr->image, cv_ptr->image, CV_BGR2BGRA);
        } else
        {
          // if necessary convert colors from rgb to bgr
          if ((image_encoding == enc::BGR8) || (image_encoding == enc::BGR16))
            cv::cvtColor(cv_ptr->image, cv_ptr->image, CV_RGB2BGR);

          if ((image_encoding == enc::BGRA8) || (image_encoding == enc::BGRA16))
            cv::cvtColor(cv_ptr->image, cv_ptr->image, CV_RGB2BGRA);

          if ((image_encoding == enc::RGBA8) || (image_encoding == enc::RGBA16))
            cv::cvtColor(cv_ptr->image, cv_ptr->image, CV_RGB2RGBA);
        }
      }
    }
  }
  catch (cv::Exception& e)
  {
    ROS_ERROR("%s", e.what());
  }

  size_t rows = cv_ptr->image.rows;
  size_t cols = cv_ptr->image.cols;

  if ((rows > 0) && (cols > 0))
    // Publish message to user callback
    user_cb(cv_ptr->toImageMsg());
}

https://github.com/ros-perception/ima...