IPSDK  4_1_0_2
IPSDK : Image Processing Software Development Kit
ImageStripSplitOperators.h
Go to the documentation of this file.
1 // ImageStripSplitOperators.h:
3 // ---------------------------
4 //
14 
15 #ifndef __IPSDKIMAGEPROCESSING_IMAGESTRIPSPLITOPERATORS_H__
16 #define __IPSDKIMAGEPROCESSING_IMAGESTRIPSPLITOPERATORS_H__
17 
18 #include <IPSDKBaseProcessing/DataSplit/Dynamic/DynamicSplitOperators.h>
19 #include <IPSDKImageProcessing/DataSplit/Strip/XStrip2d/ImageXStrip2dSplit.h>
20 #include <IPSDKImageProcessing/DataSplit/Strip/XStrip2dWithKernel/ImageXStrip2dWithKernelSplit.h>
21 #include <IPSDKImageProcessing/DataSplit/Strip/YStrip2d/ImageYStrip2dSplit.h>
22 #include <IPSDKImageProcessing/DataSplit/Strip/YSubStrip2d/ImageYSubStrip2dSplit.h>
23 #include <IPSDKImageProcessing/DataSplit/Strip/YStrip2dWithKernel/ImageYStrip2dWithKernelSplit.h>
24 #include <IPSDKImageProcessing/DataSplit/Strip/YStrip3d/ImageYStrip3dSplit.h>
25 #include <IPSDKImageProcessing/DataSplit/Strip/YStripColor2d/ImageYStripColor2dSplit.h>
26 #include <IPSDKImageProcessing/DataSplit/Strip/YStripSeq2d/ImageYStripSeq2dSplit.h>
27 #include <IPSDKImageProcessing/DataSplit/Strip/ZStrip3d/ImageZStrip3dSplit.h>
28 #include <IPSDKImageProcessing/DataSplit/Strip/ZStrip3dWithKernel/ImageZStrip3dWithKernelSplit.h>
29 #include <IPSDKImageProcessing/DataSplit/Strip/ZStripColor3d/ImageZStripColor3dSplit.h>
30 #include <IPSDKImageProcessing/DataSplit/Strip/ZSubStrip3d/ImageZSubStrip3dSplit.h>
31 #include <IPSDKImageProcessing/DataSplit/Strip/PreviousYStrip2d/PreviousImageYStrip2dSplit.h>
32 #include <IPSDKImageProcessing/DataSplit/Strip/PreviousZStrip3d/PreviousImageZStrip3dSplit.h>
33 #include <IPSDKBaseData/Pattern/StructuringElement/StructuringElementTypes.h>
34 #include <boost/mpl/if.hpp>
35 #include <boost/mpl/bool.hpp>
36 #include <boost/make_shared.hpp>
37 
38 namespace ipsdk {
39 namespace imaproc {
40 
43 
46 template <typename TProcessor, typename TAttribute>
47 inline boost::shared_ptr<ImageYStrip2dSplit<TProcessor, image::BaseImage, TAttribute> >
48 yStrip2dSplit(const image::ImagePtr& pImage,
49  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
50 {
51  typedef ImageYStrip2dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
52  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
53  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, stripParsingDirection, stripParsingDirection);
54 
55  return pDataSplit;
56 }
57 
58 template <typename TProcessor, typename TAttribute>
59 inline boost::shared_ptr<ImageYStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> >
60 yStrip2dSplit(const image::ImageConstPtr& pImage,
61  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
62  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
63 {
64  typedef ImageYStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
65  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
66  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection, stripParsingDirection);
67 
68  return pDataSplit;
69 }
70 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
71 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
72  boost::shared_ptr<ImageYStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
73 yStrip2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
74  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
75  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
76 {
77  return yStrip2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripParsingDirection);
78 }
79 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
80 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
81  boost::shared_ptr<ImageYStrip2dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
82 yStrip2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
83  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
84 {
85  return yStrip2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripParsingDirection);
86 }
87 
88 // Functions with different parsing along x and y
89 
90 template <typename TProcessor, typename TAttribute>
91 inline boost::shared_ptr<ImageYStrip2dSplit<TProcessor, image::BaseImage, TAttribute> >
92 yStrip2dSplit(const image::ImagePtr& pImage,
93  const image::eStripParsingDirection& stripParsingDirection,
94  const image::eStripParsingDirection& lineParsingDirection)
95 {
96  typedef ImageYStrip2dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
97  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
98  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, stripParsingDirection, lineParsingDirection);
99 
100  return pDataSplit;
101 }
102 
103 template <typename TProcessor, typename TAttribute>
104 inline boost::shared_ptr<ImageYStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> >
105 yStrip2dSplit(const image::ImageConstPtr& pImage,
106  const image::eStripAllocationType& stripAllocationType,
107  const image::eStripParsingDirection& stripParsingDirection,
108  const image::eStripParsingDirection& lineParsingDirection)
109 {
110  typedef ImageYStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
111  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
112  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection, lineParsingDirection);
113 
114  return pDataSplit;
115 }
116 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
117 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
118  boost::shared_ptr<ImageYStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
119 yStrip2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
120  const image::eStripAllocationType& stripAllocationType,
121  const image::eStripParsingDirection& stripParsingDirection,
122  const image::eStripParsingDirection& lineParsingDirection)
123 {
124  return yStrip2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripAllocationType, lineParsingDirection);
125 }
126 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
127 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
128  boost::shared_ptr<ImageYStrip2dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
129 yStrip2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
130  const image::eStripParsingDirection& stripParsingDirection,
131  const image::eStripParsingDirection& lineParsingDirection)
132 {
133  return yStrip2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), image::eStripAllocationType::eSAT_NoAllocation, stripParsingDirection, lineParsingDirection);
134 }
136 
139 template <typename TProcessor, typename TAttribute>
140 inline boost::shared_ptr<ImageYSubStrip2dSplit<TProcessor, image::BaseImage, TAttribute> >
141 ySubStrip2dSplit(const image::ImagePtr& pImage,
142  ipUInt64 yOffset,
143  ipUInt64 nbRows)
144 {
145  typedef ImageYSubStrip2dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
146  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
147  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, yOffset, nbRows);
148 
149  return pDataSplit;
150 }
151 template <typename TProcessor, typename TAttribute>
152 inline boost::shared_ptr<ImageYSubStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> >
153 ySubStrip2dSplit(const image::ImageConstPtr& pImage,
154  ipUInt64 yOffset,
155  ipUInt64 nbRows,
156  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation)
157 {
158  typedef ImageYSubStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
159  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
160  pDataSplit->init(pImage, stripAllocationType, yOffset, nbRows);
161 
162  return pDataSplit;
163 }
164 
165 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
166 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
167  boost::shared_ptr<ImageYSubStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
168 ySubStrip2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
169  ipUInt64 yOffset,
170  ipUInt64 nbRows,
171  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation)
172 {
173  return ySubStrip2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), yOffset, nbRows, stripAllocationType);
174 }
175 
176 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
177 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
178  boost::shared_ptr<ImageYSubStrip2dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
179 ySubStrip2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
180  ipUInt64 yOffset,
181  ipUInt64 nbRows)
182 {
183  return ySubStrip2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), yOffset, nbRows);
184 }
186 
189 template <typename TProcessor, typename TAttribute>
190 inline boost::shared_ptr<ImageXStrip2dSplit<TProcessor, image::BaseImage, TAttribute> >
191 xStrip2dSplit(const image::ImagePtr& pImage,
192  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
193 {
194  typedef ImageXStrip2dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
195  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
196  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, stripParsingDirection);
197 
198  return pDataSplit;
199 }
200 template <typename TProcessor, typename TAttribute>
201 inline boost::shared_ptr<ImageXStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> >
202 xStrip2dSplit(const image::ImageConstPtr& pImage,
203  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
204  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
205 {
206  typedef ImageXStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
207  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
208  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection);
209 
210  return pDataSplit;
211 }
212 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
213 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
214  boost::shared_ptr<ImageXStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
215 xStrip2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
216  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
217  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
218 {
219  return xStrip2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripParsingDirection);
220 }
221 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
222 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
223  boost::shared_ptr<ImageXStrip2dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
224 xStrip2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
225  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
226 {
227  return xStrip2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripParsingDirection);
228 }
230 
233 template <typename TProcessor, typename TAttribute>
234 inline boost::shared_ptr<ImageYStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> >
235 yStrip2dWithKernelSplit(const image::ImageConstPtr& pImage,
236  const KernelXY& kernelXY,
237  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
238  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
239 {
240  typedef ImageYStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
241  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
242  pDataSplit->init(pImage, kernelXY, stripAllocationType, stripParsingDirection);
243 
244  return pDataSplit;
245 }
246 template <typename TProcessor, typename TAttribute>
247 inline boost::shared_ptr<ImageYStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> >
248 yStrip2dWithKernelSplit(const image::ImageConstPtr& pImage,
249  const StructuringElementXY& structuringElementXY,
250  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
251  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
252 {
253  typedef ImageYStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
254  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
255  pDataSplit->init(pImage, structuringElementXY, stripAllocationType, stripParsingDirection);
256 
257  return pDataSplit;
258 }
259 template <typename TProcessor, typename TAttribute>
260 inline boost::shared_ptr<ImageYStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> >
261 yStrip2dWithKernelSplit(const image::ImageConstPtr& pImage,
262  const ipUInt64 startingKernelSizeX,
263  const ipUInt64 endingKernelSizeX,
264  const ipUInt64 startingKernelSizeY,
265  const ipUInt64 endingKernelSizeY,
266  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
267  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
268 {
269  typedef ImageYStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
270  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
271  pDataSplit->init(pImage, startingKernelSizeX, endingKernelSizeX, startingKernelSizeY, endingKernelSizeY, stripAllocationType, stripParsingDirection);
272 
273  return pDataSplit;
274 }
275 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
276 inline boost::shared_ptr<ImageYStrip2dWithKernelSplit<TProcessor,
277  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutput>,
278  image::BaseImage,
279  const image::BaseImage
280  >::type,
281  TAttribute> >
282 yStrip2dWithKernelSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
283  const KernelXY& kernelXY,
284  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
285  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
286 {
287  return yStrip2dWithKernelSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), kernelXY, stripAllocationType, stripParsingDirection);
288 }
289 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
290 inline boost::shared_ptr<ImageYStrip2dWithKernelSplit<TProcessor,
291  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutput>,
292  image::BaseImage,
293  const image::BaseImage
294  >::type,
295  TAttribute> >
296 yStrip2dWithKernelSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
297  const StructuringElementXY& structuringElementXY,
298  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
299  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
300 {
301  return yStrip2dWithKernelSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), structuringElementXY, stripAllocationType, stripParsingDirection);
302 }
303 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
304 inline boost::shared_ptr<ImageYStrip2dWithKernelSplit<TProcessor,
305  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutput>,
306  image::BaseImage,
307  const image::BaseImage
308  >::type,
309  TAttribute> >
310 yStrip2dWithKernelSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
311  const ipUInt64 startingKernelSizeX,
312  const ipUInt64 endingKernelSizeX,
313  const ipUInt64 startingKernelSizeY,
314  const ipUInt64 endingKernelSizeY,
315  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
316  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
317 {
318  return yStrip2dWithKernelSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), startingKernelSizeX, endingKernelSizeX, startingKernelSizeY, endingKernelSizeY, stripAllocationType, stripParsingDirection);
319 }
321 
324 template <typename TProcessor, typename TAttribute>
325 inline boost::shared_ptr<ImageXStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> >
326 xStrip2dWithKernelSplit(const image::ImageConstPtr& pImage,
327  const KernelXY& kernelXY,
328  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
329  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct,
330  const ipUInt64 nbMaxEltsPerSplit = NumericLimits<ipUInt64>::max())
331 {
332  typedef ImageXStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
333  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
334  pDataSplit->init(pImage, kernelXY, stripAllocationType, stripParsingDirection, nbMaxEltsPerSplit);
335 
336  return pDataSplit;
337 }
338 template <typename TProcessor, typename TAttribute>
339 inline boost::shared_ptr<ImageXStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> >
340 xStrip2dWithKernelSplit(const image::ImageConstPtr& pImage,
341  const StructuringElementXY& structuringElementXY,
342  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
343  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct,
344  const ipUInt64 nbMaxEltsPerSplit = NumericLimits<ipUInt64>::max())
345 {
346  typedef ImageXStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
347  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
348  pDataSplit->init(pImage, structuringElementXY, stripAllocationType, stripParsingDirection, nbMaxEltsPerSplit);
349 
350  return pDataSplit;
351 }
352 template <typename TProcessor, typename TAttribute>
353 inline boost::shared_ptr<ImageXStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> >
354 xStrip2dWithKernelSplit(const image::ImageConstPtr& pImage,
355  const ipUInt64 startingKernelSizeX,
356  const ipUInt64 endingKernelSizeX,
357  const ipUInt64 startingKernelSizeY,
358  const ipUInt64 endingKernelSizeY,
359  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
360  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct,
361  const ipUInt64 nbMaxEltsPerSplit = NumericLimits<ipUInt64>::max())
362 {
363  typedef ImageXStrip2dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
364  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
365  pDataSplit->init(pImage, startingKernelSizeX, endingKernelSizeX, startingKernelSizeY, endingKernelSizeY, stripAllocationType, stripParsingDirection, nbMaxEltsPerSplit);
366 
367  return pDataSplit;
368 }
369 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
370 inline boost::shared_ptr<ImageXStrip2dWithKernelSplit<TProcessor,
371  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutput>,
372  image::BaseImage,
373  const image::BaseImage
374  >::type,
375  TAttribute> >
376 xStrip2dWithKernelSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
377  const KernelXY& kernelXY,
378  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
379  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct,
380  const ipUInt64 nbMaxEltsPerSplit = NumericLimits<ipUInt64>::max())
381 {
382  return xStrip2dWithKernelSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), kernelXY, stripAllocationType, stripParsingDirection, nbMaxEltsPerSplit);
383 }
384 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
385 inline boost::shared_ptr<ImageXStrip2dWithKernelSplit<TProcessor,
386  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutput>,
387  image::BaseImage,
388  const image::BaseImage
389  >::type,
390  TAttribute> >
391 xStrip2dWithKernelSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
392  const StructuringElementXY& structuringElementXY,
393  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
394  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct,
395  const ipUInt64 nbMaxEltsPerSplit = NumericLimits<ipUInt64>::max())
396 {
397  return xStrip2dWithKernelSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), structuringElementXY, stripAllocationType, stripParsingDirection, nbMaxEltsPerSplit);
398 }
399 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
400 inline boost::shared_ptr<ImageXStrip2dWithKernelSplit<TProcessor,
401  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutput>,
402  image::BaseImage,
403  const image::BaseImage
404  >::type,
405  TAttribute> >
406 xStrip2dWithKernelSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
407  const ipUInt64 startingKernelSizeX,
408  const ipUInt64 endingKernelSizeX,
409  const ipUInt64 startingKernelSizeY,
410  const ipUInt64 endingKernelSizeY,
411  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
412  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct,
413  const ipUInt64 nbMaxEltsPerSplit = NumericLimits<ipUInt64>::max())
414 {
415  return xStrip2dWithKernelSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), startingKernelSizeX, endingKernelSizeX, startingKernelSizeY, endingKernelSizeY, stripAllocationType, stripParsingDirection, nbMaxEltsPerSplit);
416 }
418 
421 template <typename TProcessor, typename TAttribute>
422 inline boost::shared_ptr<ImageYStrip3dSplit<TProcessor, image::BaseImage, TAttribute> >
423 yStrip3dSplit(const image::ImagePtr& pImage,
424  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
425 {
426  typedef ImageYStrip3dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
427  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
428  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, stripParsingDirection);
429 
430  return pDataSplit;
431 }
432 template <typename TProcessor, typename TAttribute>
433 inline boost::shared_ptr<ImageYStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> >
434 yStrip3dSplit(const image::ImageConstPtr& pImage,
435  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
436  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
437 {
438  typedef ImageYStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
439  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
440  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection);
441 
442  return pDataSplit;
443 }
444 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
445 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
446  boost::shared_ptr<ImageYStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
447 yStrip3dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
448  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
449  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
450 {
451  return yStrip3dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripParsingDirection);
452 }
453 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
454 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
455  boost::shared_ptr<ImageYStrip3dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
456 yStrip3dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
457  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
458 {
459  return yStrip3dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripParsingDirection);
460 }
462 
465 template <typename TProcessor, typename TAttribute>
466 inline boost::shared_ptr<ImageYStripColor2dSplit<TProcessor, image::BaseImage, TAttribute> >
467 yStripColor2dSplit(const image::ImagePtr& pImage,
468  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
469 {
470  typedef ImageYStripColor2dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
471  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
472  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, stripParsingDirection, false);
473 
474  return pDataSplit;
475 }
476 template <typename TProcessor, typename TAttribute>
477 inline boost::shared_ptr<ImageYStripColor2dSplit<TProcessor, const image::BaseImage, TAttribute> >
478 yStripColor2dSplit(const image::ImageConstPtr& pImage,
479  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
480  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
481 {
482  typedef ImageYStripColor2dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
483  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
484  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection, false);
485 
486  return pDataSplit;
487 }
488 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
489 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
490  boost::shared_ptr<ImageYStripColor2dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
491 yStripColor2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
492  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
493  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
494 {
495  return yStripColor2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripParsingDirection);
496 }
497 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
498 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
499  boost::shared_ptr<ImageYStripColor2dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
500 yStripColor2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
501  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
502 {
503  return yStripColor2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripParsingDirection);
504 }
506 
510 template <typename TProcessor, typename TAttribute>
511 inline boost::shared_ptr<ImageYStripColor2dSplit<TProcessor, image::BaseImage, TAttribute> >
512 yStripColorOrGrey2dSplit(const image::ImagePtr& pImage,
513  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
514 {
515  typedef ImageYStripColor2dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
516  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
517  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, stripParsingDirection, true);
518 
519  return pDataSplit;
520 }
521 template <typename TProcessor, typename TAttribute>
522 inline boost::shared_ptr<ImageYStripColor2dSplit<TProcessor, const image::BaseImage, TAttribute> >
523 yStripColorOrGrey2dSplit(const image::ImageConstPtr& pImage,
524  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
525  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
526 {
527  typedef ImageYStripColor2dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
528  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
529  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection, true);
530 
531  return pDataSplit;
532 }
533 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
534 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
535  boost::shared_ptr<ImageYStripColor2dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
536 yStripColorOrGrey2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
537  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
538  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
539 {
540  return yStripColorOrGrey2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripParsingDirection);
541 }
542 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
543 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
544  boost::shared_ptr<ImageYStripColor2dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
545 yStripColorOrGrey2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
546  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
547 {
548  return yStripColorOrGrey2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripParsingDirection);
549 }
551 
554 template <typename TProcessor, typename TAttribute>
555 inline boost::shared_ptr<ImageYStripSeq2dSplit<TProcessor, image::BaseImage, TAttribute> >
556 yStripSeq2dSplit(const image::ImagePtr& pImage,
557  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
558 {
559  typedef ImageYStripSeq2dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
560  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
561  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, stripParsingDirection);
562 
563  return pDataSplit;
564 }
565 template <typename TProcessor, typename TAttribute>
566 inline boost::shared_ptr<ImageYStripSeq2dSplit<TProcessor, const image::BaseImage, TAttribute> >
567 yStripSeq2dSplit(const image::ImageConstPtr& pImage,
568  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
569  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
570 {
571  typedef ImageYStripSeq2dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
572  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
573  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection);
574 
575  return pDataSplit;
576 }
577 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
578 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
579  boost::shared_ptr<ImageYStripSeq2dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
580 yStripSeq2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
581  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
582  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
583 {
584  return yStripSeq2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripParsingDirection);
585 }
586 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
587 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
588  boost::shared_ptr<ImageYStripSeq2dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
589 yStripSeq2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
590  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
591 {
592  return yStripSeq2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripParsingDirection);
593 }
595 
598 template <typename TProcessor, typename TAttribute>
599 inline boost::shared_ptr<ImageZStrip3dSplit<TProcessor, image::BaseImage, TAttribute> >
600 zStrip3dSplit(const image::ImagePtr& pImage,
601  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
602 {
603  typedef ImageZStrip3dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
604  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
605  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, stripParsingDirection);
606 
607  return pDataSplit;
608 }
609 template <typename TProcessor, typename TAttribute>
610 inline boost::shared_ptr<ImageZStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> >
611 zStrip3dSplit(const image::ImageConstPtr& pImage,
612  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
613  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
614 {
615  typedef ImageZStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
616  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
617  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection);
618 
619  return pDataSplit;
620 }
621 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
622 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
623  boost::shared_ptr<ImageZStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
624 zStrip3dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
625  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
626  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
627 {
628  return zStrip3dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripParsingDirection);
629 }
630 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
631 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
632  boost::shared_ptr<ImageZStrip3dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
633 zStrip3dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
634  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
635 {
636  return zStrip3dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripParsingDirection);
637 }
639 
642 template <typename TProcessor, typename TAttribute>
643 inline boost::shared_ptr<ImageZSubStrip3dSplit<TProcessor, image::BaseImage, TAttribute> >
644 zSubStrip3dSplit(const image::ImagePtr& pImage,
645  ipUInt64 zOffset,
646  ipUInt64 nbZPlans)
647 {
648  typedef ImageZSubStrip3dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
649  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
650  pDataSplit->init(pImage, image::eStripAllocationType::eSAT_NoAllocation, zOffset, nbZPlans);
651 
652  return pDataSplit;
653 }
654 template <typename TProcessor, typename TAttribute>
655 inline boost::shared_ptr<ImageZSubStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> >
656 zSubStrip3dSplit(const image::ImageConstPtr& pImage,
657  ipUInt64 zOffset,
658  ipUInt64 nbZPlans,
659  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation)
660 {
661  typedef ImageZSubStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
662  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
663  pDataSplit->init(pImage, stripAllocationType, zOffset, nbZPlans);
664 
665  return pDataSplit;
666 }
667 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
668 inline typename boost::disable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
669  boost::shared_ptr<ImageZSubStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> > >::type
670 zSubStrip3dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
671  ipUInt64 zOffset,
672  ipUInt64 nbZPlans,
673  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation)
674 {
675  return zSubStrip3dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), zOffset, nbZPlans, stripAllocationType);
676 }
677 
678 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
679 inline typename boost::enable_if<boost::mpl::bool_<TInputAttribute::g_bOutput>,
680  boost::shared_ptr<ImageZSubStrip3dSplit<TProcessor, image::BaseImage, TAttribute> > >::type
681 zSubStrip3dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
682  ipUInt64 zOffset,
683  ipUInt64 nbZPlans)
684 {
685  return zSubStrip3dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), zOffset, nbZPlans);
686 }
688 
691 template <typename TProcessor, typename TAttribute>
692 inline boost::shared_ptr<ImageZStripColor3dSplit<TProcessor, image::BaseImage, TAttribute> >
693 zStripColor3dSplit(const image::ImagePtr& pImage,
694  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
695  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
696 {
697  typedef ImageZStripColor3dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
698  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
699  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection, false);
700 
701  return pDataSplit;
702 }
703 template <typename TProcessor, typename TAttribute>
704 inline boost::shared_ptr<ImageZStripColor3dSplit<TProcessor, const image::BaseImage, TAttribute> >
705 zStripColor3dSplit(const image::ImageConstPtr& pImage,
706  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
707  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
708 {
709  typedef ImageZStripColor3dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
710  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
711  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection, false);
712 
713  return pDataSplit;
714 }
715 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
716 inline boost::shared_ptr<ImageZStripColor3dSplit<TProcessor,
717  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutputAttribute>,
718  image::BaseImage,
719  const image::BaseImage
720  >::type,
721  TAttribute> >
722 zStripColor3dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
723  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
724  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
725 {
726  return zStripColor3dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripParsingDirection);
727 }
729 
733 template <typename TProcessor, typename TAttribute>
734 inline boost::shared_ptr<ImageZStripColor3dSplit<TProcessor, image::BaseImage, TAttribute> >
735 zStripColorOrGrey3dSplit(const image::ImagePtr& pImage,
736  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
737  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
738 {
739  typedef ImageZStripColor3dSplit<TProcessor, image::BaseImage, TAttribute> DataSplit;
740  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
741  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection, true);
742 
743  return pDataSplit;
744 }
745 template <typename TProcessor, typename TAttribute>
746 inline boost::shared_ptr<ImageZStripColor3dSplit<TProcessor, const image::BaseImage, TAttribute> >
747 zStripColorOrGrey3dSplit(const image::ImageConstPtr& pImage,
748  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
749  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
750 {
751  typedef ImageZStripColor3dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
752  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
753  pDataSplit->init(pImage, stripAllocationType, stripParsingDirection, true);
754 
755  return pDataSplit;
756 }
757 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
758 inline boost::shared_ptr<ImageZStripColor3dSplit<TProcessor,
759  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutputAttribute>,
760  image::BaseImage,
761  const image::BaseImage
762  >::type,
763  TAttribute> >
764 zStripColorOrGrey3dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
765  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
766  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
767 {
768  return zStripColorOrGrey3dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripAllocationType, stripParsingDirection);
769 }
771 
774 template <typename TProcessor, typename TAttribute>
775 inline boost::shared_ptr<ImageZStrip3dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> >
776 zStrip3dWithKernelSplit(const image::ImageConstPtr& pImage,
777  const KernelXYZ& kernelXYZ,
778  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
779  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
780 {
781  typedef ImageZStrip3dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
782  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
783  pDataSplit->init(pImage, kernelXYZ, stripAllocationType, stripParsingDirection);
784 
785  return pDataSplit;
786 }
787 template <typename TProcessor, typename TAttribute>
788 inline boost::shared_ptr<ImageZStrip3dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> >
789 zStrip3dWithKernelSplit(const image::ImageConstPtr& pImage,
790  const StructuringElementXYZ& structuringElementXYZ,
791  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
792  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
793 {
794  typedef ImageZStrip3dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
795  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
796  pDataSplit->init(pImage, structuringElementXYZ, stripAllocationType, stripParsingDirection);
797 
798  return pDataSplit;
799 }
800 template <typename TProcessor, typename TAttribute>
801 inline boost::shared_ptr<ImageZStrip3dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> >
802 zStrip3dWithKernelSplit(const image::ImageConstPtr& pImage,
803  const ipUInt64 startingKernelSizeX,
804  const ipUInt64 endingKernelSizeX,
805  const ipUInt64 startingKernelSizeY,
806  const ipUInt64 endingKernelSizeY,
807  const ipUInt64 startingKernelSizeZ,
808  const ipUInt64 endingKernelSizeZ,
809  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
810  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
811 {
812  typedef ImageZStrip3dWithKernelSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
813  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
814  pDataSplit->init(pImage, startingKernelSizeX, endingKernelSizeX, startingKernelSizeY, endingKernelSizeY, startingKernelSizeZ, endingKernelSizeZ, stripAllocationType, stripParsingDirection);
815 
816  return pDataSplit;
817 }
818 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
819 inline boost::shared_ptr<ImageZStrip3dWithKernelSplit<TProcessor,
820  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutput>,
821  image::BaseImage,
822  const image::BaseImage
823  >::type,
824  TAttribute> >
825 zStrip3dWithKernelSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
826  const KernelXYZ& kernelXYZ,
827  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
828  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
829 {
830  return zStrip3dWithKernelSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), kernelXYZ, stripAllocationType, stripParsingDirection);
831 }
832 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
833 inline boost::shared_ptr<ImageZStrip3dWithKernelSplit<TProcessor,
834  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutput>,
835  image::BaseImage,
836  const image::BaseImage
837  >::type,
838  TAttribute> >
839 zStrip3dWithKernelSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
840  const StructuringElementXYZ& structuringElementXYZ,
841  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
842  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
843 {
844  return zStrip3dWithKernelSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), structuringElementXYZ, stripAllocationType, stripParsingDirection);
845 }
846 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
847 inline boost::shared_ptr<ImageZStrip3dWithKernelSplit<TProcessor,
848  typename boost::mpl::if_<boost::mpl::bool_<TInputAttribute::g_bOutput>,
849  image::BaseImage,
850  const image::BaseImage
851  >::type,
852  TAttribute> >
853 zStrip3dWithKernelSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
854  const ipUInt64 startingKernelSizeX,
855  const ipUInt64 endingKernelSizeX,
856  const ipUInt64 startingKernelSizeY,
857  const ipUInt64 endingKernelSizeY,
858  const ipUInt64 startingKernelSizeZ,
859  const ipUInt64 endingKernelSizeZ,
860  const image::eStripAllocationType& stripAllocationType = image::eStripAllocationType::eSAT_NoAllocation,
861  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
862 {
863  return zStrip3dWithKernelSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), startingKernelSizeX, endingKernelSizeX, startingKernelSizeY, endingKernelSizeY, startingKernelSizeZ, endingKernelSizeZ, stripAllocationType, stripParsingDirection);
864 }
866 
869 template <typename TProcessor, typename TAttribute>
870 inline boost::shared_ptr<PreviousImageYStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> >
871 previousYStrip2dSplit(const image::ImageConstPtr& pImage,
872  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
873 {
874  typedef PreviousImageYStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
875  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
876  pDataSplit->init(pImage, stripParsingDirection);
877 
878  return pDataSplit;
879 }
880 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
881 inline boost::shared_ptr<PreviousImageYStrip2dSplit<TProcessor, const image::BaseImage, TAttribute> >
882 previousYStrip2dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
883  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
884 {
885  return previousYStrip2dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripParsingDirection);
886 }
888 
891 template <typename TProcessor, typename TAttribute>
892 inline boost::shared_ptr<PreviousImageZStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> >
893 previousZStrip3dSplit(const image::ImageConstPtr& pImage,
894  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
895 {
896  typedef PreviousImageZStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> DataSplit;
897  boost::shared_ptr<DataSplit> pDataSplit = boost::make_shared<DataSplit>();
898  pDataSplit->init(pImage, stripParsingDirection);
899 
900  return pDataSplit;
901 }
902 template <typename TProcessor, typename TAttribute, typename TInputAttribute>
903 inline boost::shared_ptr<PreviousImageZStrip3dSplit<TProcessor, const image::BaseImage, TAttribute> >
904 previousZStrip3dSplit(const boost::shared_ptr<TInputAttribute>& pInputAttribute,
905  const image::eStripParsingDirection& stripParsingDirection = image::eStripParsingDirection::eSPD_Direct)
906 {
907  return previousZStrip3dSplit<TProcessor, TAttribute>(pInputAttribute->getStorage(), stripParsingDirection);
908 }
910 
913 
914 } // end of namespace imaproc
915 } // end of namespace ipsdk
916 
917 #endif // __IPSDKIMAGEPROCESSING_IMAGESTRIPSPLITOPERATORS_H__
ipsdk::imaproc::ImageYStripColor2dSplit
Concrete class for split operation generating color image y strips 2d.
Definition: ImageYStripColor2dSplit.h:27
ipsdk
Main namespace for IPSDK library.
Definition: AlgorithmFunctionEfficiency.h:22
ipsdk::imaproc::ImageZStrip3dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection)
initialization method for splitted objects
Definition: ImageZStrip3dSplit.h:99
ipsdk::imaproc::ImageYStripColor2dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection, const bool bAllowGreyColorGeometry)
initialization method for splitted objects
Definition: ImageYStripColor2dSplit.h:100
ipsdk::imaproc::ImageYStrip2dSplit
Concrete class for split operation generating image y strips 2d.
Definition: ImageYStrip2dSplit.h:27
ipsdk::KernelXY
Class encapsulating a 2d kernel spanning along x and y axis.
Definition: KernelXY.h:34
ipsdk::imaproc::previousYStrip2dSplit
boost::shared_ptr< PreviousImageYStrip2dSplit< TProcessor, const image::BaseImage, TAttribute > > previousYStrip2dSplit(const image::ImageConstPtr &pImage, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:871
ipsdk::imaproc::ImageZStripColor3dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection, const bool bAllowGreyColorGeometry)
initialization method for splitted objects
Definition: ImageZStripColor3dSplit.h:100
ipsdk::ipUInt64
uint64_t ipUInt64
Base types definition.
Definition: BaseTypes.h:55
ipsdk::imaproc::xStrip2dSplit
boost::shared_ptr< ImageXStrip2dSplit< TProcessor, image::BaseImage, TAttribute > > xStrip2dSplit(const image::ImagePtr &pImage, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:191
ipsdk::imaproc::ImageXStrip2dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection)
initialization method for splitted objects
Definition: ImageXStrip2dSplit.h:99
ipsdk::image::ImagePtr
boost::shared_ptr< BaseImage > ImagePtr
Definition: ImageTypes.h:139
ipsdk::imaproc::ImageYStripSeq2dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection)
initialization method for splitted objects
Definition: ImageYStripSeq2dSplit.h:100
ipsdk::imaproc::yStripSeq2dSplit
boost::shared_ptr< ImageYStripSeq2dSplit< TProcessor, image::BaseImage, TAttribute > > yStripSeq2dSplit(const image::ImagePtr &pImage, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:556
ipsdk::imaproc::ImageYStrip2dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection)
initialization method for splitted objects
Definition: ImageYStrip2dSplit.h:105
ipsdk::imaproc::ySubStrip2dSplit
boost::shared_ptr< ImageYSubStrip2dSplit< TProcessor, image::BaseImage, TAttribute > > ySubStrip2dSplit(const image::ImagePtr &pImage, ipUInt64 yOffset, ipUInt64 nbRows)
Definition: ImageStripSplitOperators.h:141
ipsdk::NumericLimits
Definition: NumericLimits.h:27
ipsdk::imaproc::ImageYStrip3dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection)
initialization method for splitted objects
Definition: ImageYStrip3dSplit.h:99
ipsdk::imaproc::ImageZStrip3dSplit
Concrete class for split operation generating image z strips 3d.
Definition: ImageZStrip3dSplit.h:27
ipsdk::imaproc::xStrip2dWithKernelSplit
boost::shared_ptr< ImageXStrip2dWithKernelSplit< TProcessor, const image::BaseImage, TAttribute > > xStrip2dWithKernelSplit(const image::ImageConstPtr &pImage, const KernelXY &kernelXY, const image::eStripAllocationType &stripAllocationType=image::eStripAllocationType::eSAT_NoAllocation, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct, const ipUInt64 nbMaxEltsPerSplit=NumericLimits< ipUInt64 >::max())
Definition: ImageStripSplitOperators.h:326
ipsdk::image::eStripAllocationType
eStripAllocationType
Enumerate describing image strip allocation policy.
Definition: ImageStripTypes.h:88
ipsdk::imaproc::zSubStrip3dSplit
boost::shared_ptr< ImageZSubStrip3dSplit< TProcessor, image::BaseImage, TAttribute > > zSubStrip3dSplit(const image::ImagePtr &pImage, ipUInt64 zOffset, ipUInt64 nbZPlans)
Definition: ImageStripSplitOperators.h:644
ipsdk::imaproc::PreviousImageYStrip2dSplit
Concrete class for split operation allowing to generate y strips 2d :
Definition: PreviousImageYStrip2dSplit.h:33
ipsdk::imaproc::zStrip3dSplit
boost::shared_ptr< ImageZStrip3dSplit< TProcessor, image::BaseImage, TAttribute > > zStrip3dSplit(const image::ImagePtr &pImage, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:600
ipsdk::imaproc::ImageYSubStrip2dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripAllocationType &stripAllocationType, ipUInt64 yOffset, ipUInt64 nbRows)
initialization method for splitted objects
Definition: ImageYSubStrip2dSplit.h:100
ipsdk::imaproc::zStripColorOrGrey3dSplit
boost::shared_ptr< ImageZStripColor3dSplit< TProcessor, image::BaseImage, TAttribute > > zStripColorOrGrey3dSplit(const image::ImagePtr &pImage, const image::eStripAllocationType &stripAllocationType=image::eStripAllocationType::eSAT_NoAllocation, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:735
ipsdk::imaproc::yStrip2dSplit
boost::shared_ptr< ImageYStrip2dSplit< TProcessor, image::BaseImage, TAttribute > > yStrip2dSplit(const image::ImagePtr &pImage, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:48
ipsdk::imaproc::zStripColor3dSplit
boost::shared_ptr< ImageZStripColor3dSplit< TProcessor, image::BaseImage, TAttribute > > zStripColor3dSplit(const image::ImagePtr &pImage, const image::eStripAllocationType &stripAllocationType=image::eStripAllocationType::eSAT_NoAllocation, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:693
ipsdk::image::eSPD_Direct
direct strip parsing direction (default behavior)
Definition: ImageStripTypes.h:76
ipsdk::imaproc::yStripColorOrGrey2dSplit
boost::shared_ptr< ImageYStripColor2dSplit< TProcessor, image::BaseImage, TAttribute > > yStripColorOrGrey2dSplit(const image::ImagePtr &pImage, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:512
ipsdk::StructuringElementXY
Class encapsulating a 2d structuring element spanning along x and y axis.
Definition: StructuringElementXY.h:32
ipsdk::imaproc::previousZStrip3dSplit
boost::shared_ptr< PreviousImageZStrip3dSplit< TProcessor, const image::BaseImage, TAttribute > > previousZStrip3dSplit(const image::ImageConstPtr &pImage, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:893
ipsdk::imaproc::ImageZStrip3dWithKernelSplit
Concrete class for split operation generating image z strips 3d associated to a kernel.
Definition: ImageZStrip3dWithKernelSplit.h:28
ipsdk::imaproc::ImageZSubStrip3dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripAllocationType &stripAllocationType, ipUInt64 zOffset, ipUInt64 nbZPlans)
initialization method for splitted objects
Definition: ImageZSubStrip3dSplit.h:100
ipsdk::imaproc::ImageYStrip2dWithKernelSplit
Concrete class for split operation generating image y strips 2d associated to a kernel.
Definition: ImageYStrip2dWithKernelSplit.h:28
ipsdk::imaproc::PreviousImageYStrip2dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripParsingDirection &stripParsingDirection)
initialization method for splitted objects
Definition: PreviousImageYStrip2dSplit.h:104
ipsdk::image::ImageConstPtr
boost::shared_ptr< const BaseImage > ImageConstPtr
Definition: ImageTypes.h:140
ipsdk::imaproc::ImageYStripSeq2dSplit
Concrete class for split operation generating sequence image y strips 2d.
Definition: ImageYStripSeq2dSplit.h:28
ipsdk::imaproc::yStripColor2dSplit
boost::shared_ptr< ImageYStripColor2dSplit< TProcessor, image::BaseImage, TAttribute > > yStripColor2dSplit(const image::ImagePtr &pImage, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:467
DynamicSplitOperators.h
Predefined operators for dynamic data split used for data dispatch.
StructuringElementTypes.h
Predefined types for structuring element management.
ipsdk::StructuringElementXYZ
Class encapsulating a 3d structuring element spanning along x, y and z axis.
Definition: StructuringElementXYZ.h:35
ipsdk::imaproc::PreviousImageZStrip3dSplit
Concrete class for split operation allowing to generate z strips 3d :
Definition: PreviousImageZStrip3dSplit.h:33
ipsdk::image::eStripParsingDirection
eStripParsingDirection
Enumerate describing strip parsing direction.
Definition: ImageStripTypes.h:72
ipsdk::imaproc::ImageZStripColor3dSplit
Concrete class for split operation generating color image z strips 3d.
Definition: ImageZStripColor3dSplit.h:27
ipsdk::imaproc::ImageYSubStrip2dSplit
Concrete class for split operation generating image y strips 2d from a subset of contiguous rows...
Definition: ImageYSubStrip2dSplit.h:27
ipsdk::imaproc::yStrip2dWithKernelSplit
boost::shared_ptr< ImageYStrip2dWithKernelSplit< TProcessor, const image::BaseImage, TAttribute > > yStrip2dWithKernelSplit(const image::ImageConstPtr &pImage, const KernelXY &kernelXY, const image::eStripAllocationType &stripAllocationType=image::eStripAllocationType::eSAT_NoAllocation, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:235
ipsdk::image::BaseImage
Base class for images data type.
Definition: BaseImage.h:43
ipsdk::imaproc::yStrip3dSplit
boost::shared_ptr< ImageYStrip3dSplit< TProcessor, image::BaseImage, TAttribute > > yStrip3dSplit(const image::ImagePtr &pImage, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:423
ipsdk::image::eSAT_NoAllocation
Do not force any allocation (standard case)
Definition: ImageStripTypes.h:90
ipsdk::imaproc::ImageXStrip2dSplit
Concrete class for split operation generating image x strips 2d.
Definition: ImageXStrip2dSplit.h:27
ipsdk::imaproc::ImageYStrip2dWithKernelSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const KernelXY &kernelXY, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection)
initialization method for splitted objects
Definition: ImageYStrip2dWithKernelSplit.h:142
ipsdk::imaproc::ImageZSubStrip3dSplit
Concrete class for split operation generating image z strips 3d from a subset of contiguous z-plans...
Definition: ImageZSubStrip3dSplit.h:27
ipsdk::imaproc::ImageXStrip2dWithKernelSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const KernelXY &kernelXY, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection, const ipUInt64 nbMaxEltsPerSplit=NumericLimits< ipUInt64 >::max())
initialization method for splitted objects
Definition: ImageXStrip2dWithKernelSplit.h:145
ipsdk::imaproc::PreviousImageZStrip3dSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const image::eStripParsingDirection &stripParsingDirection)
initialization method for splitted objects
Definition: PreviousImageZStrip3dSplit.h:104
ipsdk::imaproc::ImageYStrip3dSplit
Concrete class for split operation generating image y strips 3d.
Definition: ImageYStrip3dSplit.h:27
ipsdk::imaproc::zStrip3dWithKernelSplit
boost::shared_ptr< ImageZStrip3dWithKernelSplit< TProcessor, const image::BaseImage, TAttribute > > zStrip3dWithKernelSplit(const image::ImageConstPtr &pImage, const KernelXYZ &kernelXYZ, const image::eStripAllocationType &stripAllocationType=image::eStripAllocationType::eSAT_NoAllocation, const image::eStripParsingDirection &stripParsingDirection=image::eStripParsingDirection::eSPD_Direct)
Definition: ImageStripSplitOperators.h:776
ipsdk::KernelXYZ
Class encapsulating a 3d kernel spanning along x, y and z axis.
Definition: KernelXYZ.h:34
ipsdk::imaproc::ImageXStrip2dWithKernelSplit
Concrete class for split operation generating image x strips 2d associated to a kernel.
Definition: ImageXStrip2dWithKernelSplit.h:28
ipsdk::imaproc::ImageZStrip3dWithKernelSplit::init
void init(const boost::shared_ptr< InputDataType > &pImage, const KernelXYZ &kernelXYZ, const image::eStripAllocationType &stripAllocationType, const image::eStripParsingDirection &stripParsingDirection)
initialization method for splitted objects
Definition: ImageZStrip3dWithKernelSplit.h:156
Generated on Tue Apr 15 2025 16:20:48 for IPSDK by   doxygen 1.8.14