modules/dnn/src/layers/crop_layer.cpp

   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 //                           License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
  14 // Copyright (C) 2017, Intel Corporation, all rights reserved.
  15 // Third party copyrights are property of their respective owners.
  16 //
  17 // Redistribution and use in source and binary forms, with or without modification,
  18 // are permitted provided that the following conditions are met:
  19 //
  20 //   * Redistribution's of source code must retain the above copyright notice,
  21 //     this list of conditions and the following disclaimer.
  22 //
  23 //   * Redistribution's in binary form must reproduce the above copyright notice,
  24 //     this list of conditions and the following disclaimer in the documentation
  25 //     and/or other materials provided with the distribution.
  26 //
  27 //   * The name of the copyright holders may not be used to endorse or promote products
  28 //     derived from this software without specific prior written permission.
  29 //
  30 // This software is provided by the copyright holders and contributors "as is" and
  31 // any express or implied warranties, including, but not limited to, the implied
  32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  33 // In no event shall the Intel Corporation or contributors be liable for any direct,
  34 // indirect, incidental, special, exemplary, or consequential damages
  35 // (including, but not limited to, procurement of substitute goods or services;
  36 // loss of use, data, or profits; or business interruption) however caused
  37 // and on any theory of liability, whether in contract, strict liability,
  38 // or tort (including negligence or otherwise) arising in any way out of
  39 // the use of this software, even if advised of the possibility of such damage.
  40 //
  41 //M*/
  42
  43 #include "../precomp.hpp"
  44 #include "layers_common.hpp"
  45
  46 namespace cv
  47 {
  48 namespace dnn
  49 {
  50
  51 class CropLayerImpl : public CropLayer
  52 {
  53 public:
  54     CropLayerImpl(const LayerParams& params)
  55     {
  56         setParamsFrom(params);
  57         startAxis = params.get<int>("axis", 2);
  58         const DictValue *paramOffset = params.ptr("offset");
  59
  60         if (paramOffset)
  61         {
  62             for (int i = 0; i < paramOffset->size(); i++)
  63                 offset.push_back(paramOffset->get<int>(i));
  64         }
  65     }
  66
  67     bool getMemoryShapes(const std::vector<MatShape> &inputs,
  68                          const int requiredOutputs,
  69                          std::vector<MatShape> &outputs,
  70                          std::vector<MatShape> &internals) const
  71     {
  72         CV_Assert(inputs.size() == 2);
  73
  74         MatShape dstShape = inputs[0];
  75         int start = clamp(startAxis, dstShape);
  76         for (int i = start; i < dstShape.size(); i++)
  77         {
  78             dstShape[i] = inputs[1][i];
  79         }
  80
  81         outputs.resize(1, dstShape);
  82
  83         return false;
  84     }
  85
  86     void finalize(const std::vector<Mat *> &inputs, std::vector<Mat> &outputs)
  87     {
  88         CV_Assert(2 == inputs.size());
  89
  90         const Mat &inpBlob = *inputs[0];
  91         const Mat &inpSzBlob = *inputs[1];
  92
  93         int dims = inpBlob.dims;
  94         int start_axis = clamp(startAxis, dims);
  95
  96         std::vector<int> offset_final(dims, 0);
  97         if (offset.size() == 1)
  98         {
  99             for (int i = start_axis; i < dims; i++)
 100                 offset_final[i] = offset[0];
 101         }
 102         else if (offset.size() > 1)
 103         {
 104             if ((int)offset.size() != dims - start_axis)
 105                 CV_Error(Error::StsBadArg, "number of offset values specified must be "
 106                                            "equal to the number of dimensions following axis.");
 107
 108             for (int i = start_axis; i < dims; i++)
 109                 offset_final[i] = offset[i - start_axis];
 110         }
 111
 112         crop_ranges.resize(dims, Range::all());
 113         for (int i = start_axis; i < dims; i++)
 114         {
 115             if (offset_final[i] < 0 || offset_final[i] + inpSzBlob.size[i] > inpBlob.size[i])
 116                 CV_Error(Error::StsBadArg, "invalid crop parameters or blob sizes");
 117
 118             crop_ranges[i] = Range(offset_final[i], offset_final[i] + inpSzBlob.size[i]);
 119         }
 120     }
 121
 122     void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr)
 123     {
 124         CV_TRACE_FUNCTION();
 125         CV_TRACE_ARG_VALUE(name, "name", name.c_str());
 126
 127         Layer::forward_fallback(inputs_arr, outputs_arr, internals_arr);
 128     }
 129
 130     void forward(std::vector<Mat *> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals)
 131     {
 132         CV_TRACE_FUNCTION();
 133         CV_TRACE_ARG_VALUE(name, "name", name.c_str());
 134
 135         Mat &input = *inputs[0];
 136         Mat &output = outputs[0];
 137
 138         input(&crop_ranges[0]).copyTo(output);
 139     }
 140
 141     std::vector<Range> crop_ranges;
 142 };
 143
 144
 145 Ptr<CropLayer> CropLayer::create(const LayerParams& params)
 146 {
 147     return Ptr<CropLayer>(new CropLayerImpl(params));
 148 }
 149
 150 }
 151 }