1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 //  By downloading, copying, installing or using the software you agree to this license.
6 //  If you do not agree to this license, do not download, install,
7 //  copy or use the software.
8 //
9 //
10 //                        Intel License Agreement
11 //                For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective icvers.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 //   * Redistribution's of source code must retain the above copyright notice,
20 //     this list of conditions and the following disclaimer.
21 //
22 //   * Redistribution's in binary form must reproduce the above copyright notice,
23 //     this list of conditions and the following disclaimer in the documentation
24 //     and/or other materials provided with the distribution.
25 //
26 //   * The name of Intel Corporation may not be used to endorse or promote products
27 //     derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //M*/
41 
42 #include "opencv2/core/base.hpp"
43 
44 #ifndef __OPENCV_DENOISING_ARRAYS_HPP__
45 #define __OPENCV_DENOISING_ARRAYS_HPP__
46 
47 namespace cv
48 {
49 
50 template <class T>
51 struct Array2d
52 {
53     T* a;
54     int n1,n2;
55     bool needToDeallocArray;
56 
Array2dcv::Array2d57     Array2d(const Array2d& array2d):
58         a(array2d.a), n1(array2d.n1), n2(array2d.n2), needToDeallocArray(false)
59     {
60         if (array2d.needToDeallocArray)
61         {
62             CV_Error(Error::BadDataPtr, "Copy constructor for self allocating arrays not supported");
63         }
64     }
65 
Array2dcv::Array2d66     Array2d(T* _a, int _n1, int _n2):
67         a(_a), n1(_n1), n2(_n2), needToDeallocArray(false)
68     {
69     }
70 
Array2dcv::Array2d71     Array2d(int _n1, int _n2):
72         n1(_n1), n2(_n2), needToDeallocArray(true)
73     {
74         a = new T[n1*n2];
75     }
76 
~Array2dcv::Array2d77     ~Array2d()
78     {
79         if (needToDeallocArray)
80             delete[] a;
81     }
82 
operator []cv::Array2d83     T* operator [] (int i)
84     {
85         return a + i*n2;
86     }
87 
row_ptrcv::Array2d88     inline T* row_ptr(int i)
89     {
90         return (*this)[i];
91     }
92 };
93 
94 template <class T>
95 struct Array3d
96 {
97     T* a;
98     int n1,n2,n3;
99     bool needToDeallocArray;
100 
Array3dcv::Array3d101     Array3d(T* _a, int _n1, int _n2, int _n3):
102         a(_a), n1(_n1), n2(_n2), n3(_n3), needToDeallocArray(false)
103     {
104     }
105 
Array3dcv::Array3d106     Array3d(int _n1, int _n2, int _n3):
107         n1(_n1), n2(_n2), n3(_n3), needToDeallocArray(true)
108     {
109         a = new T[n1*n2*n3];
110     }
111 
~Array3dcv::Array3d112     ~Array3d()
113     {
114         if (needToDeallocArray)
115             delete[] a;
116     }
117 
operator []cv::Array3d118     Array2d<T> operator [] (int i)
119     {
120         Array2d<T> array2d(a + i*n2*n3, n2, n3);
121         return array2d;
122     }
123 
row_ptrcv::Array3d124     inline T* row_ptr(int i1, int i2)
125     {
126         return a + i1*n2*n3 + i2*n3;
127     }
128 };
129 
130 template <class T>
131 struct Array4d
132 {
133     T* a;
134     int n1,n2,n3,n4;
135     bool needToDeallocArray;
136     int steps[4];
137 
init_stepscv::Array4d138     void init_steps()
139     {
140         steps[0] = n2*n3*n4;
141         steps[1] = n3*n4;
142         steps[2] = n4;
143         steps[3] = 1;
144     }
145 
Array4dcv::Array4d146     Array4d(T* _a, int _n1, int _n2, int _n3, int _n4) :
147         a(_a), n1(_n1), n2(_n2), n3(_n3), n4(_n4), needToDeallocArray(false)
148     {
149         init_steps();
150     }
151 
Array4dcv::Array4d152     Array4d(int _n1, int _n2, int _n3, int _n4) :
153         n1(_n1), n2(_n2), n3(_n3), n4(_n4), needToDeallocArray(true)
154     {
155         a = new T[n1*n2*n3*n4];
156         init_steps();
157     }
158 
~Array4dcv::Array4d159     ~Array4d()
160     {
161         if (needToDeallocArray)
162             delete[] a;
163     }
164 
operator []cv::Array4d165     Array3d<T> operator [] (int i)
166     {
167         Array3d<T> array3d(a + i*n2*n3*n4, n2, n3, n4);
168         return array3d;
169     }
170 
row_ptrcv::Array4d171     inline T* row_ptr(int i1, int i2, int i3)
172     {
173         return a + i1*n2*n3*n4 + i2*n3*n4 + i3*n4;
174     }
175 
step_sizecv::Array4d176     inline int step_size(int dimension)
177     {
178         return steps[dimension];
179     }
180 };
181 
182 }
183 
184 #endif
185