If you accept that Const just means "won't be manipulated from here", as most of your question seems to imply, a const_image isn't immutable.

Seems like your class is a smart-pointer with extra accessors and (if non-const) manipulators.

You might benefit from basing it on [`std::shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr).

Next, to emulate deep-const, your `Image`-class needs to do the following:

1. Ensure a const instance lacks manipulators.

 That's easily done, just make sure no manipulator-method is `const`-qualified, and all inspector-methods are.

 int getX() const; // inspector
 int setX(); // manipulator

2. Ensure a const instance does not expose any non-deep-const internal state.

 Any inspector-method only returns const-qualified references or equivalent pointers, and only for state which itself emulates deep-const, or does not have any linked state. 
 Naturally deep-copies may always be returned. (Deep-copies and Shallow copies are trivially equivalent for state without internal links.)

3. Ensure a non-const instance cannot be constructed from a const instance.

 Now this last point looks like a back-breaker, as C++ unfortuately does not allow making a constructor `const`. 
 Fortunately, we can get around that with more code: Just declare a second class.

<!-- -->

 struct image;
 struct const_image {
 // ctors, dtor, const inspectors
 // no manipulators, and only expose as const_image, other deep-const type or deep-copy
 private:
 friend class image;
 // explicitly defaulted (move-)assignment-operators
 // Whatever members are neccessary to maintain the data.
 // Probably only a single shared_ptr and some indices
 };

 struct image : const_image {
 // delegating ctors for all but copy-construction and move-constructor
 // copy-ctor accepting a non-const image, probably defaulted
 // move-constructor, (move-)assignment-operators
 // additional non-const inspectors (where possible a thin mask over the const ones)
 // these all return Image or manipulatable internal state
 // manipulators
 private:
 // if neccessary, optional additional state for supporting manipulation-operations
 };