text: // Copyright (c) 2018 Intel Corporation
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  //      http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  
  #include "border_inst.h"
  
  #include "error_handler.h"
  #include "json_object.h"
  #include "primitive_type_base.h"
  
  
  namespace cldnn
  {
  primitive_type_id border_type_id()
  {
      static primitive_type_base<border> instance;
      return &instance;
  }
  
  layout border_inst::calc_output_layout(border_node const& node)
  {
      assert((bool)node.get_primitive()->get_output_data_type() == false
             && "Output data type forcing is not supported for border_node!");
      auto input_layout = node.input().get_output_layout();
      auto desc         = node.get_primitive();
  
      auto&& new_size = input_layout.size;
      new_size += desc->left_top_sizes.sub({0, 0, 0, 0});
      new_size += desc->right_bottom_sizes.sub({0, 0, 0, 0});
  
      return { input_layout.data_type, input_layout.format, {new_size.batch[0], new_size.feature[0], new_size.spatial[0], new_size.spatial[1]} };
  }
  
  std::string border_inst::to_string(border_node const& node)
  {
      auto desc = node.get_primitive();
  
      const auto& left_top_sizes     = desc->left_top_sizes.sub({0, 0, 0, 0});
      const auto& right_bottom_sizes = desc->right_bottom_sizes.sub({0, 0, 0, 0});
      const auto& border_value       = std::to_string(desc->border_value);
  
      const char* border_type_str = "unknown";
      switch (desc->type)
      {
      case border_type::constant:   border_type_str = "constant";   break;
      case border_type::edge:       border_type_str = "edge";       break;
      case border_type::mirror:     border_type_str = "mirror";     break;
      case border_type::mirror_101: border_type_str = "mirror-101"; break;
      }
  
      auto node_info  = node.desc_to_json();
     
      json_composite border_info;
      border_info.add("left/top sizes",     left_top_sizes.to_string());
      border_info.add("right/bottom sizes", right_bottom_sizes.to_string());
      border_info.add("border type",        border_type_str);
      border_info.add("border value",       border_value);
  
      node_info->add("border info", border_info);
  
      std::stringstream primitive_description;
      node_info->dump(primitive_description);
      return primitive_description.str();
  }
  
  border_inst::typed_primitive_inst(network_impl& network, border_node const& node)
      : parent(network, node)
  {
      auto input_layout = node.input().get_output_layout();
  
      const auto input_format = input_layout.format;
      const auto& input_sizes = input_layout.size;
  
      auto lt_sizes = argument.left_top_sizes.sub({0, 0, 0, 0});
      auto rb_sizes = argument.right_bottom_sizes.sub({0, 0, 0, 0});
      auto b_type   = argument.type;
  
      CLDNN_ERROR_NOT_PROPER_FORMAT(node.id(), "Input format", input_format.value, "supported border primitive input formats",
                                    format::bfyx, format::yxfb, format::byxf);
  
  
      // Check if sizes of border are in proper range.
      CLDNN_ERROR_TENSOR_SIZES_LESS_THAN(node.id(), "Left/Top border sizes", lt_sizes, "0 value", {0, 0, 0, 0},
                                         "Invalid border size: negative value");
      CLDNN_ERROR_TENSOR_SIZES_LESS_THAN(node.id(), "Right/Bottom border sizes", rb_sizes, "0 value", {0, 0, 0, 0},
                                         "Invalid border size: negative value");
  
      if (b_type == border_type::mirror)
      {
          CLDNN_ERROR_TENSOR_SIZES_GREATER_THAN(node.id(), "Left/Top border sizes", lt_sizes, "input_sizes", input_sizes,
                                                "Not enough data in input to create mirror border of specified size");
          CLDNN_ERROR_TENSOR_SIZES_GREATER_THAN(node.id(), "Right/Bottom border sizes", rb_sizes, "input_sizes", input_sizes,
                                                "Not enough data in input to create mirror border of specified size");
      }
      else if (b_type == border_type::mirror_101)
      {
          auto reduced_input_sizes = input_sizes;
          reduced_input_sizes -= tensor(1);
          reduced_input_sizes = tensor::max(reduced_input_sizes, tensor());
  
          CLDNN_ERROR_TENSOR_SIZES_GREATER_THAN(node.id(), "Left/Top border sizes", lt_sizes, "input_sizes - 1", reduced_input_sizes,
                                                "Not enough data in input to create mirror-101 border of specified size");
          CLDNN_ERROR_TENSOR_SIZES_GREATER_THAN(node.id(), "Right/Bottom border sizes", rb_sizes, "input_sizes - 1", reduced_input_sizes,
                                                "Not enough data in input to create mirror-101 border of specified size");
      }
  }
  }
  