Multithreading, shared queue as synchronization point
Not a Queue!

First and foremost, your SharedQueue isn't a queue. You can only store one element in it at a time. That doesn't make it super useful - what if the producer wants to write two images?

queue.setImage(img1);
queue.setImage(img2); // blocks?


It's more of a guarantee-one-at-a-time container. A queue would be much more useful, so I'd consider actually implementing one. This is a pretty major design flaw.



Beyond that, I just have minor comments.

Move semantics

You have a lot of copies where you can do moves. For instance, in SetImage():

next_image_ = image;


should be:

next_image_ = std::move(image);


Moving is cheaper than copying (no need to incur reference counting). 

Checking shared_ptr

You don't need to use .get(), you can directly check the shared_ptr:

image_processed_.wait(lock, [this]{
   return !next_image_ || stop_;
});


Clear()

You use a std::unique_lock&lt;&gt; to Clear() where a std::lock_guard&lt;&gt; is sufficient. You use the correct one in SetFinish().