diff --git a/modules/viz/include/opencv2/viz/widgets.hpp b/modules/viz/include/opencv2/viz/widgets.hpp
index 54edf205ee..ba601ca869 100644
--- a/modules/viz/include/opencv2/viz/widgets.hpp
+++ b/modules/viz/include/opencv2/viz/widgets.hpp
@@ -155,9 +155,6 @@ namespace cv
             ImageOverlayWidget(const Mat &image, const Rect &rect);
             
             void setImage(const Mat &image);
-            
-        private:
-            struct CopyImpl;
         };
         
         class CV_EXPORTS Image3DWidget : public Widget3D
@@ -167,9 +164,6 @@ namespace cv
             Image3DWidget(const Vec3f &position, const Vec3f &normal, const Vec3f &up_vector, const Mat &image, const Size &size);
             
             void setImage(const Mat &image);
-        
-        private:
-            struct CopyImpl;
         };
         
         class CV_EXPORTS CameraPositionWidget : public Widget3D
@@ -181,8 +175,6 @@ namespace cv
             CameraPositionWidget(const Vec2f &fov, double scale = 1.0, const Color &color = Color::white());
             CameraPositionWidget(const Matx33f &K, const Mat &img, double scale = 1.0);
             
-        private:
-            struct CopyImpl;
         };
         
         class CV_EXPORTS TrajectoryWidget : public Widget3D
diff --git a/modules/viz/src/shape_widgets.cpp b/modules/viz/src/shape_widgets.cpp
index fc8e80ea6d..4fee4072a2 100644
--- a/modules/viz/src/shape_widgets.cpp
+++ b/modules/viz/src/shape_widgets.cpp
@@ -629,69 +629,13 @@ cv::String cv::viz::TextWidget::getText() const
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// image overlay widget implementation
 
-struct cv::viz::ImageOverlayWidget::CopyImpl
-{
-    struct Impl
-    {
-        static void copyImageMultiChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
-        {
-            int i_chs = image.channels();
-    
-            for (int i = 0; i < image.rows; ++i)
-            {
-                const unsigned char * irows = image.ptr<unsigned char>(i);
-                for (int j = 0; j < image.cols; ++j, irows += i_chs)
-                {
-                    unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
-                    memcpy(vrows, irows, i_chs);
-                    std::swap(vrows[0], vrows[2]); // BGR -> RGB
-                }
-            }
-            output->Modified();
-        }
-        
-        static void copyImageSingleChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
-        {
-            for (int i = 0; i < image.rows; ++i)
-            {
-                const unsigned char * irows = image.ptr<unsigned char>(i);
-                for (int j = 0; j < image.cols; ++j, ++irows)
-                {
-                    unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
-                    *vrows = *irows;
-                }
-            }
-            output->Modified();
-        }
-    };
-    
-    static void copyImage(const Mat &image, vtkSmartPointer<vtkImageData> output)
-    {
-        int i_chs = image.channels();
-        if (i_chs > 1)
-        {
-            // Multi channel images are handled differently because of BGR <-> RGB
-            Impl::copyImageMultiChannel(image, output);
-        }
-        else
-        {
-            Impl::copyImageSingleChannel(image, output);
-        }
-    }
-};
-
 cv::viz::ImageOverlayWidget::ImageOverlayWidget(const Mat &image, const Rect &rect)
 {
     CV_Assert(!image.empty() && image.depth() == CV_8U);
     
     // Create the vtk image and set its parameters based on input image
     vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
-    vtk_image->SetDimensions(image.cols, image.rows, 1);
-    vtk_image->SetNumberOfScalarComponents(image.channels());
-    vtk_image->SetScalarTypeToUnsignedChar();
-    vtk_image->AllocateScalars();
-    
-    CopyImpl::copyImage(image, vtk_image);
+    ConvertToVtkImage::convert(image, vtk_image);
     
     // Need to flip the image as the coordinates are different in OpenCV and VTK
     vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@@ -734,12 +678,7 @@ void cv::viz::ImageOverlayWidget::setImage(const Mat &image)
     
     // Create the vtk image and set its parameters based on input image
     vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
-    vtk_image->SetDimensions(image.cols, image.rows, 1);
-    vtk_image->SetNumberOfScalarComponents(image.channels());
-    vtk_image->SetScalarTypeToUnsignedChar();
-    vtk_image->AllocateScalars();
-    
-    CopyImpl::copyImage(image, vtk_image);
+    ConvertToVtkImage::convert(image, vtk_image);
     
     // Need to flip the image as the coordinates are different in OpenCV and VTK
     vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@@ -759,69 +698,13 @@ template<> cv::viz::ImageOverlayWidget cv::viz::Widget::cast<cv::viz::ImageOverl
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// image 3D widget implementation
 
-struct cv::viz::Image3DWidget::CopyImpl
-{
-    struct Impl
-    {
-        static void copyImageMultiChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
-        {
-            int i_chs = image.channels();
-    
-            for (int i = 0; i < image.rows; ++i)
-            {
-                const unsigned char * irows = image.ptr<unsigned char>(i);
-                for (int j = 0; j < image.cols; ++j, irows += i_chs)
-                {
-                    unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
-                    memcpy(vrows, irows, i_chs);
-                    std::swap(vrows[0], vrows[2]); // BGR -> RGB
-                }
-            }
-            output->Modified();
-        }
-        
-        static void copyImageSingleChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
-        {
-            for (int i = 0; i < image.rows; ++i)
-            {
-                const unsigned char * irows = image.ptr<unsigned char>(i);
-                for (int j = 0; j < image.cols; ++j, ++irows)
-                {
-                    unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
-                    *vrows = *irows;
-                }
-            }
-            output->Modified();
-        }
-    };
-    
-    static void copyImage(const Mat &image, vtkSmartPointer<vtkImageData> output)
-    {
-        int i_chs = image.channels();
-        if (i_chs > 1)
-        {
-            // Multi channel images are handled differently because of BGR <-> RGB
-            Impl::copyImageMultiChannel(image, output);
-        }
-        else
-        {
-            Impl::copyImageSingleChannel(image, output);
-        }
-    }
-};
-
 cv::viz::Image3DWidget::Image3DWidget(const Mat &image, const Size &size)
 {
     CV_Assert(!image.empty() && image.depth() == CV_8U);
     
     // Create the vtk image and set its parameters based on input image
     vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
-    vtk_image->SetDimensions(image.cols, image.rows, 1);
-    vtk_image->SetNumberOfScalarComponents(image.channels());
-    vtk_image->SetScalarTypeToUnsignedChar();
-    vtk_image->AllocateScalars();
-    
-    CopyImpl::copyImage(image, vtk_image);
+    ConvertToVtkImage::convert(image, vtk_image);
     
     // Need to flip the image as the coordinates are different in OpenCV and VTK
     vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@@ -869,12 +752,7 @@ cv::viz::Image3DWidget::Image3DWidget(const Vec3f &position, const Vec3f &normal
     
     // Create the vtk image and set its parameters based on input image
     vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
-    vtk_image->SetDimensions(image.cols, image.rows, 1);
-    vtk_image->SetNumberOfScalarComponents(image.channels());
-    vtk_image->SetScalarTypeToUnsignedChar();
-    vtk_image->AllocateScalars();
-    
-    CopyImpl::copyImage(image, vtk_image);
+    ConvertToVtkImage::convert(image, vtk_image);
     
     // Need to flip the image as the coordinates are different in OpenCV and VTK
     vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@@ -947,12 +825,7 @@ void cv::viz::Image3DWidget::setImage(const Mat &image)
     
     // Create the vtk image and set its parameters based on input image
     vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
-    vtk_image->SetDimensions(image.cols, image.rows, 1);
-    vtk_image->SetNumberOfScalarComponents(image.channels());
-    vtk_image->SetScalarTypeToUnsignedChar();
-    vtk_image->AllocateScalars();
-    
-    CopyImpl::copyImage(image, vtk_image);
+    ConvertToVtkImage::convert(image, vtk_image);
     
     // Need to flip the image as the coordinates are different in OpenCV and VTK
     vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@@ -976,58 +849,6 @@ template<> cv::viz::Image3DWidget cv::viz::Widget::cast<cv::viz::Image3DWidget>(
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// camera position widget implementation
 
-struct cv::viz::CameraPositionWidget::CopyImpl
-{
-    struct Impl
-    {
-        static void copyImageMultiChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
-        {
-            int i_chs = image.channels();
-    
-            for (int i = 0; i < image.rows; ++i)
-            {
-                const unsigned char * irows = image.ptr<unsigned char>(i);
-                for (int j = 0; j < image.cols; ++j, irows += i_chs)
-                {
-                    unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
-                    memcpy(vrows, irows, i_chs);
-                    std::swap(vrows[0], vrows[2]); // BGR -> RGB
-                }
-            }
-            output->Modified();
-        }
-        
-        static void copyImageSingleChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
-        {
-            for (int i = 0; i < image.rows; ++i)
-            {
-                const unsigned char * irows = image.ptr<unsigned char>(i);
-                for (int j = 0; j < image.cols; ++j, ++irows)
-                {
-                    unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
-                    *vrows = *irows;
-                }
-            }
-            output->Modified();
-        }
-    };
-    
-    static void copyImage(const Mat &image, vtkSmartPointer<vtkImageData> output)
-    {
-        int i_chs = image.channels();
-        if (i_chs > 1)
-        {
-            // Multi channel images are handled differently because of BGR <-> RGB
-            Impl::copyImageMultiChannel(image, output);
-        }
-        else
-        {
-            Impl::copyImageSingleChannel(image, output);
-        }
-    }
-};
-
-
 cv::viz::CameraPositionWidget::CameraPositionWidget(double scale)
 {
     vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New ();
@@ -1223,14 +1044,9 @@ cv::viz::CameraPositionWidget::CameraPositionWidget(const Matx33f &K, const Mat
     float fovy = 2.0f * atan2(c_y,f_y) * 180 / CV_PI;
     float far_end_height = 2.0f * c_y * scale / f_y;
     
-    // Create the vtk image and set its parameters based on input image
+    // Create the vtk image
     vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
-    vtk_image->SetDimensions(image.cols, image.rows, 1);
-    vtk_image->SetNumberOfScalarComponents(image.channels());
-    vtk_image->SetScalarTypeToUnsignedChar();
-    vtk_image->AllocateScalars();
-    
-    CopyImpl::copyImage(image, vtk_image);
+    ConvertToVtkImage::convert(image, vtk_image);
     
     // Need to flip the image as the coordinates are different in OpenCV and VTK
     vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
diff --git a/modules/viz/src/viz3d_impl.hpp b/modules/viz/src/viz3d_impl.hpp
index 04b816d485..c6bef09885 100644
--- a/modules/viz/src/viz3d_impl.hpp
+++ b/modules/viz/src/viz3d_impl.hpp
@@ -410,6 +410,63 @@ namespace cv
 
         inline Vec3d vtkpoint(const Point3f& point) { return Vec3d(point.x, point.y, point.z); }
         template<typename _Tp> inline _Tp normalized(const _Tp& v) { return v * 1/cv::norm(v); }
+        
+        struct ConvertToVtkImage
+        {
+            struct Impl
+            {
+                static void copyImageMultiChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
+                {
+                    int i_chs = image.channels();
+            
+                    for (int i = 0; i < image.rows; ++i)
+                    {
+                        const unsigned char * irows = image.ptr<unsigned char>(i);
+                        for (int j = 0; j < image.cols; ++j, irows += i_chs)
+                        {
+                            unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
+                            memcpy(vrows, irows, i_chs);
+                            std::swap(vrows[0], vrows[2]); // BGR -> RGB
+                        }
+                    }
+                    output->Modified();
+                }
+                
+                static void copyImageSingleChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
+                {
+                    for (int i = 0; i < image.rows; ++i)
+                    {
+                        const unsigned char * irows = image.ptr<unsigned char>(i);
+                        for (int j = 0; j < image.cols; ++j, ++irows)
+                        {
+                            unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
+                            *vrows = *irows;
+                        }
+                    }
+                    output->Modified();
+                }
+            };
+            
+            static void convert(const Mat &image, vtkSmartPointer<vtkImageData> output)
+            {
+                // Create the vtk image
+                output->SetDimensions(image.cols, image.rows, 1);
+                output->SetNumberOfScalarComponents(image.channels());
+                output->SetScalarTypeToUnsignedChar();
+                output->AllocateScalars();
+                
+                int i_chs = image.channels();
+                if (i_chs > 1)
+                {
+                    // Multi channel images are handled differently because of BGR <-> RGB
+                    Impl::copyImageMultiChannel(image, output);
+                }
+                else
+                {
+                    Impl::copyImageSingleChannel(image, output);
+                }
+            }
+        };
     }
 
 }