File render_data.pb.cc

File List > mediapipe > util > render_data.pb.cc

Go to the documentation of this file

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: mediapipe/util/render_data.proto

#include "mediapipe/util/render_data.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace mediapipe {
constexpr RenderData::RenderData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : render_annotations_()
  , scene_class_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , scene_viewport_(nullptr){}
struct RenderDataDefaultTypeInternal {
  constexpr RenderDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderDataDefaultTypeInternal() {}
  union {
    RenderData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderDataDefaultTypeInternal _RenderData_default_instance_;
constexpr RenderAnnotation_Rectangle::RenderAnnotation_Rectangle(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : left_(0)
  , top_(0)
  , right_(0)
  , bottom_(0)
  , rotation_(0)
  , top_left_thickness_(0)
  , normalized_(false){}
struct RenderAnnotation_RectangleDefaultTypeInternal {
  constexpr RenderAnnotation_RectangleDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_RectangleDefaultTypeInternal() {}
  union {
    RenderAnnotation_Rectangle _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_RectangleDefaultTypeInternal _RenderAnnotation_Rectangle_default_instance_;
constexpr RenderAnnotation_FilledRectangle::RenderAnnotation_FilledRectangle(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : rectangle_(nullptr)
  , fill_color_(nullptr){}
struct RenderAnnotation_FilledRectangleDefaultTypeInternal {
  constexpr RenderAnnotation_FilledRectangleDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_FilledRectangleDefaultTypeInternal() {}
  union {
    RenderAnnotation_FilledRectangle _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_FilledRectangleDefaultTypeInternal _RenderAnnotation_FilledRectangle_default_instance_;
constexpr RenderAnnotation_RoundedRectangle::RenderAnnotation_RoundedRectangle(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : rectangle_(nullptr)
  , corner_radius_(0)
  , line_type_(4){}
struct RenderAnnotation_RoundedRectangleDefaultTypeInternal {
  constexpr RenderAnnotation_RoundedRectangleDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_RoundedRectangleDefaultTypeInternal() {}
  union {
    RenderAnnotation_RoundedRectangle _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_RoundedRectangleDefaultTypeInternal _RenderAnnotation_RoundedRectangle_default_instance_;
constexpr RenderAnnotation_FilledRoundedRectangle::RenderAnnotation_FilledRoundedRectangle(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : rounded_rectangle_(nullptr)
  , fill_color_(nullptr){}
struct RenderAnnotation_FilledRoundedRectangleDefaultTypeInternal {
  constexpr RenderAnnotation_FilledRoundedRectangleDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_FilledRoundedRectangleDefaultTypeInternal() {}
  union {
    RenderAnnotation_FilledRoundedRectangle _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_FilledRoundedRectangleDefaultTypeInternal _RenderAnnotation_FilledRoundedRectangle_default_instance_;
constexpr RenderAnnotation_Oval::RenderAnnotation_Oval(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : rectangle_(nullptr){}
struct RenderAnnotation_OvalDefaultTypeInternal {
  constexpr RenderAnnotation_OvalDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_OvalDefaultTypeInternal() {}
  union {
    RenderAnnotation_Oval _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_OvalDefaultTypeInternal _RenderAnnotation_Oval_default_instance_;
constexpr RenderAnnotation_FilledOval::RenderAnnotation_FilledOval(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : oval_(nullptr)
  , fill_color_(nullptr){}
struct RenderAnnotation_FilledOvalDefaultTypeInternal {
  constexpr RenderAnnotation_FilledOvalDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_FilledOvalDefaultTypeInternal() {}
  union {
    RenderAnnotation_FilledOval _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_FilledOvalDefaultTypeInternal _RenderAnnotation_FilledOval_default_instance_;
constexpr RenderAnnotation_Point::RenderAnnotation_Point(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : x_(0)
  , y_(0)
  , normalized_(false){}
struct RenderAnnotation_PointDefaultTypeInternal {
  constexpr RenderAnnotation_PointDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_PointDefaultTypeInternal() {}
  union {
    RenderAnnotation_Point _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_PointDefaultTypeInternal _RenderAnnotation_Point_default_instance_;
constexpr RenderAnnotation_Line::RenderAnnotation_Line(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : x_start_(0)
  , y_start_(0)
  , x_end_(0)
  , y_end_(0)
  , normalized_(false)
  , line_type_(1)
{}
struct RenderAnnotation_LineDefaultTypeInternal {
  constexpr RenderAnnotation_LineDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_LineDefaultTypeInternal() {}
  union {
    RenderAnnotation_Line _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_LineDefaultTypeInternal _RenderAnnotation_Line_default_instance_;
constexpr RenderAnnotation_GradientLine::RenderAnnotation_GradientLine(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : color1_(nullptr)
  , color2_(nullptr)
  , x_start_(0)
  , y_start_(0)
  , x_end_(0)
  , y_end_(0)
  , normalized_(false){}
struct RenderAnnotation_GradientLineDefaultTypeInternal {
  constexpr RenderAnnotation_GradientLineDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_GradientLineDefaultTypeInternal() {}
  union {
    RenderAnnotation_GradientLine _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_GradientLineDefaultTypeInternal _RenderAnnotation_GradientLine_default_instance_;
constexpr RenderAnnotation_Scribble::RenderAnnotation_Scribble(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : point_(){}
struct RenderAnnotation_ScribbleDefaultTypeInternal {
  constexpr RenderAnnotation_ScribbleDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_ScribbleDefaultTypeInternal() {}
  union {
    RenderAnnotation_Scribble _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_ScribbleDefaultTypeInternal _RenderAnnotation_Scribble_default_instance_;
constexpr RenderAnnotation_Arrow::RenderAnnotation_Arrow(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : x_start_(0)
  , y_start_(0)
  , x_end_(0)
  , y_end_(0)
  , normalized_(false){}
struct RenderAnnotation_ArrowDefaultTypeInternal {
  constexpr RenderAnnotation_ArrowDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_ArrowDefaultTypeInternal() {}
  union {
    RenderAnnotation_Arrow _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_ArrowDefaultTypeInternal _RenderAnnotation_Arrow_default_instance_;
constexpr RenderAnnotation_Text::RenderAnnotation_Text(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : display_text_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , outline_color_(nullptr)
  , left_(0)
  , baseline_(0)
  , font_face_(0)
  , normalized_(false)
  , center_horizontally_(false)
  , center_vertically_(false)
  , outline_thickness_(0)
  , font_height_(8){}
struct RenderAnnotation_TextDefaultTypeInternal {
  constexpr RenderAnnotation_TextDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotation_TextDefaultTypeInternal() {}
  union {
    RenderAnnotation_Text _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotation_TextDefaultTypeInternal _RenderAnnotation_Text_default_instance_;
constexpr RenderAnnotation::RenderAnnotation(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : scene_tag_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , color_(nullptr)
  , thickness_(1)
  , _oneof_case_{}{}
struct RenderAnnotationDefaultTypeInternal {
  constexpr RenderAnnotationDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderAnnotationDefaultTypeInternal() {}
  union {
    RenderAnnotation _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderAnnotationDefaultTypeInternal _RenderAnnotation_default_instance_;
constexpr RenderViewport::RenderViewport(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , width_px_(0)
  , height_px_(0)
  , compose_on_video_(false){}
struct RenderViewportDefaultTypeInternal {
  constexpr RenderViewportDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RenderViewportDefaultTypeInternal() {}
  union {
    RenderViewport _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RenderViewportDefaultTypeInternal _RenderViewport_default_instance_;
}  // namespace mediapipe
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[15];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_mediapipe_2futil_2frender_5fdata_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_mediapipe_2futil_2frender_5fdata_2eproto = nullptr;

const uint32_t TableStruct_mediapipe_2futil_2frender_5fdata_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderData, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderData, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderData, render_annotations_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderData, scene_class_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderData, scene_viewport_),
  ~0u,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Rectangle, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Rectangle, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Rectangle, left_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Rectangle, top_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Rectangle, right_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Rectangle, bottom_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Rectangle, normalized_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Rectangle, rotation_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Rectangle, top_left_thickness_),
  0,
  1,
  2,
  3,
  6,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledRectangle, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledRectangle, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledRectangle, rectangle_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledRectangle, fill_color_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_RoundedRectangle, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_RoundedRectangle, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_RoundedRectangle, rectangle_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_RoundedRectangle, corner_radius_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_RoundedRectangle, line_type_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledRoundedRectangle, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledRoundedRectangle, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledRoundedRectangle, rounded_rectangle_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledRoundedRectangle, fill_color_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Oval, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Oval, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Oval, rectangle_),
  0,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledOval, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledOval, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledOval, oval_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_FilledOval, fill_color_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Point, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Point, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Point, x_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Point, y_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Point, normalized_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Line, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Line, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Line, x_start_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Line, y_start_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Line, x_end_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Line, y_end_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Line, normalized_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Line, line_type_),
  0,
  1,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_GradientLine, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_GradientLine, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_GradientLine, x_start_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_GradientLine, y_start_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_GradientLine, x_end_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_GradientLine, y_end_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_GradientLine, normalized_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_GradientLine, color1_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_GradientLine, color2_),
  2,
  3,
  4,
  5,
  6,
  0,
  1,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Scribble, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Scribble, point_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Arrow, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Arrow, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Arrow, x_start_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Arrow, y_start_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Arrow, x_end_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Arrow, y_end_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Arrow, normalized_),
  0,
  1,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, display_text_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, left_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, baseline_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, font_height_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, normalized_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, font_face_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, center_horizontally_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, center_vertically_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, outline_thickness_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation_Text, outline_color_),
  0,
  2,
  3,
  9,
  5,
  4,
  6,
  7,
  8,
  1,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation, thickness_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation, color_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation, scene_tag_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderAnnotation, data_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  2,
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderViewport, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderViewport, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderViewport, id_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderViewport, width_px_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderViewport, height_px_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::RenderViewport, compose_on_video_),
  0,
  1,
  2,
  3,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 9, -1, sizeof(::mediapipe::RenderData)},
  { 12, 25, -1, sizeof(::mediapipe::RenderAnnotation_Rectangle)},
  { 32, 40, -1, sizeof(::mediapipe::RenderAnnotation_FilledRectangle)},
  { 42, 51, -1, sizeof(::mediapipe::RenderAnnotation_RoundedRectangle)},
  { 54, 62, -1, sizeof(::mediapipe::RenderAnnotation_FilledRoundedRectangle)},
  { 64, 71, -1, sizeof(::mediapipe::RenderAnnotation_Oval)},
  { 72, 80, -1, sizeof(::mediapipe::RenderAnnotation_FilledOval)},
  { 82, 91, -1, sizeof(::mediapipe::RenderAnnotation_Point)},
  { 94, 106, -1, sizeof(::mediapipe::RenderAnnotation_Line)},
  { 112, 125, -1, sizeof(::mediapipe::RenderAnnotation_GradientLine)},
  { 132, -1, -1, sizeof(::mediapipe::RenderAnnotation_Scribble)},
  { 139, 150, -1, sizeof(::mediapipe::RenderAnnotation_Arrow)},
  { 155, 171, -1, sizeof(::mediapipe::RenderAnnotation_Text)},
  { 181, 203, -1, sizeof(::mediapipe::RenderAnnotation)},
  { 218, 228, -1, sizeof(::mediapipe::RenderViewport)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderData_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_Rectangle_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_FilledRectangle_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_RoundedRectangle_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_FilledRoundedRectangle_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_Oval_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_FilledOval_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_Point_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_Line_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_GradientLine_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_Scribble_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_Arrow_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_Text_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderAnnotation_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_RenderViewport_default_instance_),
};

const char descriptor_table_protodef_mediapipe_2futil_2frender_5fdata_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n mediapipe/util/render_data.proto\022\tmedi"
  "apipe\032\032mediapipe/util/color.proto\"\215\001\n\nRe"
  "nderData\0227\n\022render_annotations\030\001 \003(\0132\033.m"
  "ediapipe.RenderAnnotation\022\023\n\013scene_class"
  "\030\002 \001(\t\0221\n\016scene_viewport\030\003 \001(\0132\031.mediapi"
  "pe.RenderViewport\"\362\022\n\020RenderAnnotation\022:"
  "\n\trectangle\030\001 \001(\0132%.mediapipe.RenderAnno"
  "tation.RectangleH\000\022G\n\020filled_rectangle\030\002"
  " \001(\0132+.mediapipe.RenderAnnotation.Filled"
  "RectangleH\000\0220\n\004oval\030\003 \001(\0132 .mediapipe.Re"
  "nderAnnotation.OvalH\000\022=\n\013filled_oval\030\004 \001"
  "(\0132&.mediapipe.RenderAnnotation.FilledOv"
  "alH\000\0222\n\005point\030\005 \001(\0132!.mediapipe.RenderAn"
  "notation.PointH\000\0220\n\004line\030\006 \001(\0132 .mediapi"
  "pe.RenderAnnotation.LineH\000\0222\n\005arrow\030\007 \001("
  "\0132!.mediapipe.RenderAnnotation.ArrowH\000\0220"
  "\n\004text\030\010 \001(\0132 .mediapipe.RenderAnnotatio"
  "n.TextH\000\022I\n\021rounded_rectangle\030\t \001(\0132,.me"
  "diapipe.RenderAnnotation.RoundedRectangl"
  "eH\000\022V\n\030filled_rounded_rectangle\030\n \001(\01322."
  "mediapipe.RenderAnnotation.FilledRounded"
  "RectangleH\000\022A\n\rgradient_line\030\016 \001(\0132(.med"
  "iapipe.RenderAnnotation.GradientLineH\000\0228"
  "\n\010scribble\030\017 \001(\0132$.mediapipe.RenderAnnot"
  "ation.ScribbleH\000\022\024\n\tthickness\030\013 \001(\001:\0011\022\037"
  "\n\005color\030\014 \001(\0132\020.mediapipe.Color\022\021\n\tscene"
  "_tag\030\r \001(\t\032\216\001\n\tRectangle\022\014\n\004left\030\001 \001(\001\022\013"
  "\n\003top\030\002 \001(\001\022\r\n\005right\030\003 \001(\001\022\016\n\006bottom\030\004 \001"
  "(\001\022\031\n\nnormalized\030\005 \001(\010:\005false\022\020\n\010rotatio"
  "n\030\006 \001(\001\022\032\n\022top_left_thickness\030\007 \001(\001\032q\n\017F"
  "illedRectangle\0228\n\trectangle\030\001 \001(\0132%.medi"
  "apipe.RenderAnnotation.Rectangle\022$\n\nfill"
  "_color\030\002 \001(\0132\020.mediapipe.Color\032|\n\020Rounde"
  "dRectangle\0228\n\trectangle\030\001 \001(\0132%.mediapip"
  "e.RenderAnnotation.Rectangle\022\030\n\rcorner_r"
  "adius\030\002 \001(\005:\0010\022\024\n\tline_type\030\003 \001(\005:\0014\032\207\001\n"
  "\026FilledRoundedRectangle\022G\n\021rounded_recta"
  "ngle\030\001 \001(\0132,.mediapipe.RenderAnnotation."
  "RoundedRectangle\022$\n\nfill_color\030\002 \001(\0132\020.m"
  "ediapipe.Color\032@\n\004Oval\0228\n\trectangle\030\001 \001("
  "\0132%.mediapipe.RenderAnnotation.Rectangle"
  "\032b\n\nFilledOval\022.\n\004oval\030\001 \001(\0132 .mediapipe"
  ".RenderAnnotation.Oval\022$\n\nfill_color\030\002 \001"
  "(\0132\020.mediapipe.Color\0328\n\005Point\022\t\n\001x\030\001 \001(\001"
  "\022\t\n\001y\030\002 \001(\001\022\031\n\nnormalized\030\003 \001(\010:\005false\032\326"
  "\001\n\004Line\022\017\n\007x_start\030\001 \001(\001\022\017\n\007y_start\030\002 \001("
  "\001\022\r\n\005x_end\030\003 \001(\001\022\r\n\005y_end\030\004 \001(\001\022\031\n\nnorma"
  "lized\030\005 \001(\010:\005false\022C\n\tline_type\030\006 \001(\0162)."
  "mediapipe.RenderAnnotation.Line.LineType"
  ":\005SOLID\".\n\010LineType\022\013\n\007UNKNOWN\020\000\022\t\n\005SOLI"
  "D\020\001\022\n\n\006DASHED\020\002\032\255\001\n\014GradientLine\022\017\n\007x_st"
  "art\030\001 \001(\001\022\017\n\007y_start\030\002 \001(\001\022\r\n\005x_end\030\003 \001("
  "\001\022\r\n\005y_end\030\004 \001(\001\022\031\n\nnormalized\030\005 \001(\010:\005fa"
  "lse\022 \n\006color1\030\006 \001(\0132\020.mediapipe.Color\022 \n"
  "\006color2\030\007 \001(\0132\020.mediapipe.Color\032<\n\010Scrib"
  "ble\0220\n\005point\030\001 \003(\0132!.mediapipe.RenderAnn"
  "otation.Point\032b\n\005Arrow\022\017\n\007x_start\030\001 \001(\001\022"
  "\017\n\007y_start\030\002 \001(\001\022\r\n\005x_end\030\003 \001(\001\022\r\n\005y_end"
  "\030\004 \001(\001\022\031\n\nnormalized\030\005 \001(\010:\005false\032\222\002\n\004Te"
  "xt\022\024\n\014display_text\030\001 \001(\t\022\014\n\004left\030\002 \001(\001\022\020"
  "\n\010baseline\030\003 \001(\001\022\026\n\013font_height\030\004 \001(\001:\0018"
  "\022\031\n\nnormalized\030\005 \001(\010:\005false\022\024\n\tfont_face"
  "\030\006 \001(\005:\0010\022\"\n\023center_horizontally\030\007 \001(\010:\005"
  "false\022 \n\021center_vertically\030\010 \001(\010:\005false\022"
  "\034\n\021outline_thickness\030\013 \001(\001:\0010\022\'\n\routline"
  "_color\030\014 \001(\0132\020.mediapipe.ColorB\006\n\004data\"["
  "\n\016RenderViewport\022\n\n\002id\030\001 \001(\t\022\020\n\010width_px"
  "\030\002 \001(\005\022\021\n\theight_px\030\003 \001(\005\022\030\n\020compose_on_"
  "video\030\004 \001(\010B2\n\037com.google.mediapipe.util"
  ".protoB\017RenderDataProto"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_deps[1] = {
  &::descriptor_table_mediapipe_2futil_2fcolor_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto = {
  false, false, 2783, descriptor_table_protodef_mediapipe_2futil_2frender_5fdata_2eproto, "mediapipe/util/render_data.proto", 
  &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once, descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_deps, 1, 15,
  schemas, file_default_instances, TableStruct_mediapipe_2futil_2frender_5fdata_2eproto::offsets,
  file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto, file_level_enum_descriptors_mediapipe_2futil_2frender_5fdata_2eproto, file_level_service_descriptors_mediapipe_2futil_2frender_5fdata_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter() {
  return &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_mediapipe_2futil_2frender_5fdata_2eproto(&descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto);
namespace mediapipe {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RenderAnnotation_Line_LineType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto);
  return file_level_enum_descriptors_mediapipe_2futil_2frender_5fdata_2eproto[0];
}
bool RenderAnnotation_Line_LineType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr RenderAnnotation_Line_LineType RenderAnnotation_Line::UNKNOWN;
constexpr RenderAnnotation_Line_LineType RenderAnnotation_Line::SOLID;
constexpr RenderAnnotation_Line_LineType RenderAnnotation_Line::DASHED;
constexpr RenderAnnotation_Line_LineType RenderAnnotation_Line::LineType_MIN;
constexpr RenderAnnotation_Line_LineType RenderAnnotation_Line::LineType_MAX;
constexpr int RenderAnnotation_Line::LineType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

// ===================================================================

class RenderData::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderData>()._has_bits_);
  static void set_has_scene_class(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::mediapipe::RenderViewport& scene_viewport(const RenderData* msg);
  static void set_has_scene_viewport(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::mediapipe::RenderViewport&
RenderData::_Internal::scene_viewport(const RenderData* msg) {
  return *msg->scene_viewport_;
}
RenderData::RenderData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  render_annotations_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderData)
}
RenderData::RenderData(const RenderData& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      render_annotations_(from.render_annotations_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  scene_class_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    scene_class_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_scene_class()) {
    scene_class_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_scene_class(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_scene_viewport()) {
    scene_viewport_ = new ::mediapipe::RenderViewport(*from.scene_viewport_);
  } else {
    scene_viewport_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderData)
}

inline void RenderData::SharedCtor() {
scene_class_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  scene_class_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
scene_viewport_ = nullptr;
}

RenderData::~RenderData() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderData)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderData::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  scene_class_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete scene_viewport_;
}

void RenderData::ArenaDtor(void* object) {
  RenderData* _this = reinterpret_cast< RenderData* >(object);
  (void)_this;
}
void RenderData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderData::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderData)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  render_annotations_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      scene_class_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(scene_viewport_ != nullptr);
      scene_viewport_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .mediapipe.RenderAnnotation render_annotations = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_render_annotations(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // optional string scene_class = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_scene_class();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.RenderData.scene_class");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.RenderViewport scene_viewport = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_scene_viewport(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderData::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderData)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .mediapipe.RenderAnnotation render_annotations = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_render_annotations_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_render_annotations(i), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // optional string scene_class = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_scene_class().data(), static_cast<int>(this->_internal_scene_class().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "mediapipe.RenderData.scene_class");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_scene_class(), target);
  }

  // optional .mediapipe.RenderViewport scene_viewport = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::scene_viewport(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderData)
  return target;
}

size_t RenderData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderData)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .mediapipe.RenderAnnotation render_annotations = 1;
  total_size += 1UL * this->_internal_render_annotations_size();
  for (const auto& msg : this->render_annotations_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string scene_class = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_scene_class());
    }

    // optional .mediapipe.RenderViewport scene_viewport = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *scene_viewport_);
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderData::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderData::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderData::GetClassData() const { return &_class_data_; }

void RenderData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderData *>(to)->MergeFrom(
      static_cast<const RenderData &>(from));
}


void RenderData::MergeFrom(const RenderData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderData)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  render_annotations_.MergeFrom(from.render_annotations_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_scene_class(from._internal_scene_class());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_scene_viewport()->::mediapipe::RenderViewport::MergeFrom(from._internal_scene_viewport());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderData::CopyFrom(const RenderData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderData::IsInitialized() const {
  return true;
}

void RenderData::InternalSwap(RenderData* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  render_annotations_.InternalSwap(&other->render_annotations_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &scene_class_, lhs_arena,
      &other->scene_class_, rhs_arena
  );
  swap(scene_viewport_, other->scene_viewport_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderData::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[0]);
}

// ===================================================================

class RenderAnnotation_Rectangle::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_Rectangle>()._has_bits_);
  static void set_has_left(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_top(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_right(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_bottom(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_normalized(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_rotation(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_top_left_thickness(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

RenderAnnotation_Rectangle::RenderAnnotation_Rectangle(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.Rectangle)
}
RenderAnnotation_Rectangle::RenderAnnotation_Rectangle(const RenderAnnotation_Rectangle& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&left_, &from.left_,
    static_cast<size_t>(reinterpret_cast<char*>(&normalized_) -
    reinterpret_cast<char*>(&left_)) + sizeof(normalized_));
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.Rectangle)
}

inline void RenderAnnotation_Rectangle::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&left_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&normalized_) -
    reinterpret_cast<char*>(&left_)) + sizeof(normalized_));
}

RenderAnnotation_Rectangle::~RenderAnnotation_Rectangle() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.Rectangle)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_Rectangle::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void RenderAnnotation_Rectangle::ArenaDtor(void* object) {
  RenderAnnotation_Rectangle* _this = reinterpret_cast< RenderAnnotation_Rectangle* >(object);
  (void)_this;
}
void RenderAnnotation_Rectangle::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_Rectangle::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_Rectangle::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.Rectangle)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    ::memset(&left_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&normalized_) -
        reinterpret_cast<char*>(&left_)) + sizeof(normalized_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_Rectangle::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double left = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
          _Internal::set_has_left(&has_bits);
          left_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double top = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_top(&has_bits);
          top_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double right = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_right(&has_bits);
          right_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double bottom = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 33)) {
          _Internal::set_has_bottom(&has_bits);
          bottom_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool normalized = 5 [default = false];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_normalized(&has_bits);
          normalized_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double rotation = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 49)) {
          _Internal::set_has_rotation(&has_bits);
          rotation_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double top_left_thickness = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 57)) {
          _Internal::set_has_top_left_thickness(&has_bits);
          top_left_thickness_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_Rectangle::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.Rectangle)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double left = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_left(), target);
  }

  // optional double top = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_top(), target);
  }

  // optional double right = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_right(), target);
  }

  // optional double bottom = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->_internal_bottom(), target);
  }

  // optional bool normalized = 5 [default = false];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_normalized(), target);
  }

  // optional double rotation = 6;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(6, this->_internal_rotation(), target);
  }

  // optional double top_left_thickness = 7;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(7, this->_internal_top_left_thickness(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.Rectangle)
  return target;
}

size_t RenderAnnotation_Rectangle::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.Rectangle)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    // optional double left = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional double top = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

    // optional double right = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

    // optional double bottom = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional double rotation = 6;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 8;
    }

    // optional double top_left_thickness = 7;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 8;
    }

    // optional bool normalized = 5 [default = false];
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 1;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_Rectangle::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_Rectangle::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_Rectangle::GetClassData() const { return &_class_data_; }

void RenderAnnotation_Rectangle::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_Rectangle *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_Rectangle &>(from));
}


void RenderAnnotation_Rectangle::MergeFrom(const RenderAnnotation_Rectangle& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.Rectangle)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    if (cached_has_bits & 0x00000001u) {
      left_ = from.left_;
    }
    if (cached_has_bits & 0x00000002u) {
      top_ = from.top_;
    }
    if (cached_has_bits & 0x00000004u) {
      right_ = from.right_;
    }
    if (cached_has_bits & 0x00000008u) {
      bottom_ = from.bottom_;
    }
    if (cached_has_bits & 0x00000010u) {
      rotation_ = from.rotation_;
    }
    if (cached_has_bits & 0x00000020u) {
      top_left_thickness_ = from.top_left_thickness_;
    }
    if (cached_has_bits & 0x00000040u) {
      normalized_ = from.normalized_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_Rectangle::CopyFrom(const RenderAnnotation_Rectangle& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.Rectangle)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_Rectangle::IsInitialized() const {
  return true;
}

void RenderAnnotation_Rectangle::InternalSwap(RenderAnnotation_Rectangle* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_Rectangle, normalized_)
      + sizeof(RenderAnnotation_Rectangle::normalized_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_Rectangle, left_)>(
          reinterpret_cast<char*>(&left_),
          reinterpret_cast<char*>(&other->left_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_Rectangle::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[1]);
}

// ===================================================================

class RenderAnnotation_FilledRectangle::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_FilledRectangle>()._has_bits_);
  static const ::mediapipe::RenderAnnotation_Rectangle& rectangle(const RenderAnnotation_FilledRectangle* msg);
  static void set_has_rectangle(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::mediapipe::Color& fill_color(const RenderAnnotation_FilledRectangle* msg);
  static void set_has_fill_color(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::mediapipe::RenderAnnotation_Rectangle&
RenderAnnotation_FilledRectangle::_Internal::rectangle(const RenderAnnotation_FilledRectangle* msg) {
  return *msg->rectangle_;
}
const ::mediapipe::Color&
RenderAnnotation_FilledRectangle::_Internal::fill_color(const RenderAnnotation_FilledRectangle* msg) {
  return *msg->fill_color_;
}
void RenderAnnotation_FilledRectangle::clear_fill_color() {
  if (fill_color_ != nullptr) fill_color_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
RenderAnnotation_FilledRectangle::RenderAnnotation_FilledRectangle(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.FilledRectangle)
}
RenderAnnotation_FilledRectangle::RenderAnnotation_FilledRectangle(const RenderAnnotation_FilledRectangle& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_rectangle()) {
    rectangle_ = new ::mediapipe::RenderAnnotation_Rectangle(*from.rectangle_);
  } else {
    rectangle_ = nullptr;
  }
  if (from._internal_has_fill_color()) {
    fill_color_ = new ::mediapipe::Color(*from.fill_color_);
  } else {
    fill_color_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.FilledRectangle)
}

inline void RenderAnnotation_FilledRectangle::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&rectangle_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fill_color_) -
    reinterpret_cast<char*>(&rectangle_)) + sizeof(fill_color_));
}

RenderAnnotation_FilledRectangle::~RenderAnnotation_FilledRectangle() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.FilledRectangle)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_FilledRectangle::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete rectangle_;
  if (this != internal_default_instance()) delete fill_color_;
}

void RenderAnnotation_FilledRectangle::ArenaDtor(void* object) {
  RenderAnnotation_FilledRectangle* _this = reinterpret_cast< RenderAnnotation_FilledRectangle* >(object);
  (void)_this;
}
void RenderAnnotation_FilledRectangle::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_FilledRectangle::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_FilledRectangle::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.FilledRectangle)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(rectangle_ != nullptr);
      rectangle_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(fill_color_ != nullptr);
      fill_color_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_FilledRectangle::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_rectangle(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.Color fill_color = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_fill_color(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_FilledRectangle::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.FilledRectangle)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::rectangle(this), target, stream);
  }

  // optional .mediapipe.Color fill_color = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::fill_color(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.FilledRectangle)
  return target;
}

size_t RenderAnnotation_FilledRectangle::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.FilledRectangle)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rectangle_);
    }

    // optional .mediapipe.Color fill_color = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *fill_color_);
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_FilledRectangle::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_FilledRectangle::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_FilledRectangle::GetClassData() const { return &_class_data_; }

void RenderAnnotation_FilledRectangle::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_FilledRectangle *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_FilledRectangle &>(from));
}


void RenderAnnotation_FilledRectangle::MergeFrom(const RenderAnnotation_FilledRectangle& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.FilledRectangle)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_rectangle()->::mediapipe::RenderAnnotation_Rectangle::MergeFrom(from._internal_rectangle());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_fill_color()->::mediapipe::Color::MergeFrom(from._internal_fill_color());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_FilledRectangle::CopyFrom(const RenderAnnotation_FilledRectangle& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.FilledRectangle)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_FilledRectangle::IsInitialized() const {
  return true;
}

void RenderAnnotation_FilledRectangle::InternalSwap(RenderAnnotation_FilledRectangle* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_FilledRectangle, fill_color_)
      + sizeof(RenderAnnotation_FilledRectangle::fill_color_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_FilledRectangle, rectangle_)>(
          reinterpret_cast<char*>(&rectangle_),
          reinterpret_cast<char*>(&other->rectangle_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_FilledRectangle::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[2]);
}

// ===================================================================

class RenderAnnotation_RoundedRectangle::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_RoundedRectangle>()._has_bits_);
  static const ::mediapipe::RenderAnnotation_Rectangle& rectangle(const RenderAnnotation_RoundedRectangle* msg);
  static void set_has_rectangle(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_corner_radius(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_line_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

const ::mediapipe::RenderAnnotation_Rectangle&
RenderAnnotation_RoundedRectangle::_Internal::rectangle(const RenderAnnotation_RoundedRectangle* msg) {
  return *msg->rectangle_;
}
RenderAnnotation_RoundedRectangle::RenderAnnotation_RoundedRectangle(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.RoundedRectangle)
}
RenderAnnotation_RoundedRectangle::RenderAnnotation_RoundedRectangle(const RenderAnnotation_RoundedRectangle& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_rectangle()) {
    rectangle_ = new ::mediapipe::RenderAnnotation_Rectangle(*from.rectangle_);
  } else {
    rectangle_ = nullptr;
  }
  ::memcpy(&corner_radius_, &from.corner_radius_,
    static_cast<size_t>(reinterpret_cast<char*>(&line_type_) -
    reinterpret_cast<char*>(&corner_radius_)) + sizeof(line_type_));
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.RoundedRectangle)
}

inline void RenderAnnotation_RoundedRectangle::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&rectangle_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&corner_radius_) -
    reinterpret_cast<char*>(&rectangle_)) + sizeof(corner_radius_));
line_type_ = 4;
}

RenderAnnotation_RoundedRectangle::~RenderAnnotation_RoundedRectangle() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.RoundedRectangle)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_RoundedRectangle::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete rectangle_;
}

void RenderAnnotation_RoundedRectangle::ArenaDtor(void* object) {
  RenderAnnotation_RoundedRectangle* _this = reinterpret_cast< RenderAnnotation_RoundedRectangle* >(object);
  (void)_this;
}
void RenderAnnotation_RoundedRectangle::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_RoundedRectangle::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_RoundedRectangle::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.RoundedRectangle)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(rectangle_ != nullptr);
    rectangle_->Clear();
  }
  if (cached_has_bits & 0x00000006u) {
    corner_radius_ = 0;
    line_type_ = 4;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_RoundedRectangle::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_rectangle(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 corner_radius = 2 [default = 0];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _Internal::set_has_corner_radius(&has_bits);
          corner_radius_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 line_type = 3 [default = 4];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_line_type(&has_bits);
          line_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_RoundedRectangle::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.RoundedRectangle)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::rectangle(this), target, stream);
  }

  // optional int32 corner_radius = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_corner_radius(), target);
  }

  // optional int32 line_type = 3 [default = 4];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_line_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.RoundedRectangle)
  return target;
}

size_t RenderAnnotation_RoundedRectangle::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.RoundedRectangle)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rectangle_);
    }

    // optional int32 corner_radius = 2 [default = 0];
    if (cached_has_bits & 0x00000002u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_corner_radius());
    }

    // optional int32 line_type = 3 [default = 4];
    if (cached_has_bits & 0x00000004u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_line_type());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_RoundedRectangle::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_RoundedRectangle::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_RoundedRectangle::GetClassData() const { return &_class_data_; }

void RenderAnnotation_RoundedRectangle::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_RoundedRectangle *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_RoundedRectangle &>(from));
}


void RenderAnnotation_RoundedRectangle::MergeFrom(const RenderAnnotation_RoundedRectangle& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.RoundedRectangle)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_rectangle()->::mediapipe::RenderAnnotation_Rectangle::MergeFrom(from._internal_rectangle());
    }
    if (cached_has_bits & 0x00000002u) {
      corner_radius_ = from.corner_radius_;
    }
    if (cached_has_bits & 0x00000004u) {
      line_type_ = from.line_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_RoundedRectangle::CopyFrom(const RenderAnnotation_RoundedRectangle& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.RoundedRectangle)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_RoundedRectangle::IsInitialized() const {
  return true;
}

void RenderAnnotation_RoundedRectangle::InternalSwap(RenderAnnotation_RoundedRectangle* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_RoundedRectangle, corner_radius_)
      + sizeof(RenderAnnotation_RoundedRectangle::corner_radius_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_RoundedRectangle, rectangle_)>(
          reinterpret_cast<char*>(&rectangle_),
          reinterpret_cast<char*>(&other->rectangle_));
  swap(line_type_, other->line_type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_RoundedRectangle::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[3]);
}

// ===================================================================

class RenderAnnotation_FilledRoundedRectangle::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_FilledRoundedRectangle>()._has_bits_);
  static const ::mediapipe::RenderAnnotation_RoundedRectangle& rounded_rectangle(const RenderAnnotation_FilledRoundedRectangle* msg);
  static void set_has_rounded_rectangle(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::mediapipe::Color& fill_color(const RenderAnnotation_FilledRoundedRectangle* msg);
  static void set_has_fill_color(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::mediapipe::RenderAnnotation_RoundedRectangle&
RenderAnnotation_FilledRoundedRectangle::_Internal::rounded_rectangle(const RenderAnnotation_FilledRoundedRectangle* msg) {
  return *msg->rounded_rectangle_;
}
const ::mediapipe::Color&
RenderAnnotation_FilledRoundedRectangle::_Internal::fill_color(const RenderAnnotation_FilledRoundedRectangle* msg) {
  return *msg->fill_color_;
}
void RenderAnnotation_FilledRoundedRectangle::clear_fill_color() {
  if (fill_color_ != nullptr) fill_color_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
RenderAnnotation_FilledRoundedRectangle::RenderAnnotation_FilledRoundedRectangle(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.FilledRoundedRectangle)
}
RenderAnnotation_FilledRoundedRectangle::RenderAnnotation_FilledRoundedRectangle(const RenderAnnotation_FilledRoundedRectangle& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_rounded_rectangle()) {
    rounded_rectangle_ = new ::mediapipe::RenderAnnotation_RoundedRectangle(*from.rounded_rectangle_);
  } else {
    rounded_rectangle_ = nullptr;
  }
  if (from._internal_has_fill_color()) {
    fill_color_ = new ::mediapipe::Color(*from.fill_color_);
  } else {
    fill_color_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.FilledRoundedRectangle)
}

inline void RenderAnnotation_FilledRoundedRectangle::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&rounded_rectangle_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fill_color_) -
    reinterpret_cast<char*>(&rounded_rectangle_)) + sizeof(fill_color_));
}

RenderAnnotation_FilledRoundedRectangle::~RenderAnnotation_FilledRoundedRectangle() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.FilledRoundedRectangle)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_FilledRoundedRectangle::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete rounded_rectangle_;
  if (this != internal_default_instance()) delete fill_color_;
}

void RenderAnnotation_FilledRoundedRectangle::ArenaDtor(void* object) {
  RenderAnnotation_FilledRoundedRectangle* _this = reinterpret_cast< RenderAnnotation_FilledRoundedRectangle* >(object);
  (void)_this;
}
void RenderAnnotation_FilledRoundedRectangle::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_FilledRoundedRectangle::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_FilledRoundedRectangle::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.FilledRoundedRectangle)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(rounded_rectangle_ != nullptr);
      rounded_rectangle_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(fill_color_ != nullptr);
      fill_color_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_FilledRoundedRectangle::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .mediapipe.RenderAnnotation.RoundedRectangle rounded_rectangle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_rounded_rectangle(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.Color fill_color = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_fill_color(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_FilledRoundedRectangle::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.FilledRoundedRectangle)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .mediapipe.RenderAnnotation.RoundedRectangle rounded_rectangle = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::rounded_rectangle(this), target, stream);
  }

  // optional .mediapipe.Color fill_color = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::fill_color(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.FilledRoundedRectangle)
  return target;
}

size_t RenderAnnotation_FilledRoundedRectangle::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.FilledRoundedRectangle)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .mediapipe.RenderAnnotation.RoundedRectangle rounded_rectangle = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rounded_rectangle_);
    }

    // optional .mediapipe.Color fill_color = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *fill_color_);
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_FilledRoundedRectangle::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_FilledRoundedRectangle::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_FilledRoundedRectangle::GetClassData() const { return &_class_data_; }

void RenderAnnotation_FilledRoundedRectangle::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_FilledRoundedRectangle *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_FilledRoundedRectangle &>(from));
}


void RenderAnnotation_FilledRoundedRectangle::MergeFrom(const RenderAnnotation_FilledRoundedRectangle& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.FilledRoundedRectangle)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_rounded_rectangle()->::mediapipe::RenderAnnotation_RoundedRectangle::MergeFrom(from._internal_rounded_rectangle());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_fill_color()->::mediapipe::Color::MergeFrom(from._internal_fill_color());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_FilledRoundedRectangle::CopyFrom(const RenderAnnotation_FilledRoundedRectangle& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.FilledRoundedRectangle)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_FilledRoundedRectangle::IsInitialized() const {
  return true;
}

void RenderAnnotation_FilledRoundedRectangle::InternalSwap(RenderAnnotation_FilledRoundedRectangle* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_FilledRoundedRectangle, fill_color_)
      + sizeof(RenderAnnotation_FilledRoundedRectangle::fill_color_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_FilledRoundedRectangle, rounded_rectangle_)>(
          reinterpret_cast<char*>(&rounded_rectangle_),
          reinterpret_cast<char*>(&other->rounded_rectangle_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_FilledRoundedRectangle::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[4]);
}

// ===================================================================

class RenderAnnotation_Oval::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_Oval>()._has_bits_);
  static const ::mediapipe::RenderAnnotation_Rectangle& rectangle(const RenderAnnotation_Oval* msg);
  static void set_has_rectangle(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::mediapipe::RenderAnnotation_Rectangle&
RenderAnnotation_Oval::_Internal::rectangle(const RenderAnnotation_Oval* msg) {
  return *msg->rectangle_;
}
RenderAnnotation_Oval::RenderAnnotation_Oval(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.Oval)
}
RenderAnnotation_Oval::RenderAnnotation_Oval(const RenderAnnotation_Oval& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_rectangle()) {
    rectangle_ = new ::mediapipe::RenderAnnotation_Rectangle(*from.rectangle_);
  } else {
    rectangle_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.Oval)
}

inline void RenderAnnotation_Oval::SharedCtor() {
rectangle_ = nullptr;
}

RenderAnnotation_Oval::~RenderAnnotation_Oval() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.Oval)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_Oval::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete rectangle_;
}

void RenderAnnotation_Oval::ArenaDtor(void* object) {
  RenderAnnotation_Oval* _this = reinterpret_cast< RenderAnnotation_Oval* >(object);
  (void)_this;
}
void RenderAnnotation_Oval::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_Oval::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_Oval::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.Oval)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(rectangle_ != nullptr);
    rectangle_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_Oval::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_rectangle(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_Oval::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.Oval)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::rectangle(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.Oval)
  return target;
}

size_t RenderAnnotation_Oval::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.Oval)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *rectangle_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_Oval::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_Oval::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_Oval::GetClassData() const { return &_class_data_; }

void RenderAnnotation_Oval::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_Oval *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_Oval &>(from));
}


void RenderAnnotation_Oval::MergeFrom(const RenderAnnotation_Oval& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.Oval)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_rectangle()) {
    _internal_mutable_rectangle()->::mediapipe::RenderAnnotation_Rectangle::MergeFrom(from._internal_rectangle());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_Oval::CopyFrom(const RenderAnnotation_Oval& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.Oval)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_Oval::IsInitialized() const {
  return true;
}

void RenderAnnotation_Oval::InternalSwap(RenderAnnotation_Oval* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(rectangle_, other->rectangle_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_Oval::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[5]);
}

// ===================================================================

class RenderAnnotation_FilledOval::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_FilledOval>()._has_bits_);
  static const ::mediapipe::RenderAnnotation_Oval& oval(const RenderAnnotation_FilledOval* msg);
  static void set_has_oval(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::mediapipe::Color& fill_color(const RenderAnnotation_FilledOval* msg);
  static void set_has_fill_color(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::mediapipe::RenderAnnotation_Oval&
RenderAnnotation_FilledOval::_Internal::oval(const RenderAnnotation_FilledOval* msg) {
  return *msg->oval_;
}
const ::mediapipe::Color&
RenderAnnotation_FilledOval::_Internal::fill_color(const RenderAnnotation_FilledOval* msg) {
  return *msg->fill_color_;
}
void RenderAnnotation_FilledOval::clear_fill_color() {
  if (fill_color_ != nullptr) fill_color_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
RenderAnnotation_FilledOval::RenderAnnotation_FilledOval(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.FilledOval)
}
RenderAnnotation_FilledOval::RenderAnnotation_FilledOval(const RenderAnnotation_FilledOval& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_oval()) {
    oval_ = new ::mediapipe::RenderAnnotation_Oval(*from.oval_);
  } else {
    oval_ = nullptr;
  }
  if (from._internal_has_fill_color()) {
    fill_color_ = new ::mediapipe::Color(*from.fill_color_);
  } else {
    fill_color_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.FilledOval)
}

inline void RenderAnnotation_FilledOval::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&oval_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fill_color_) -
    reinterpret_cast<char*>(&oval_)) + sizeof(fill_color_));
}

RenderAnnotation_FilledOval::~RenderAnnotation_FilledOval() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.FilledOval)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_FilledOval::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete oval_;
  if (this != internal_default_instance()) delete fill_color_;
}

void RenderAnnotation_FilledOval::ArenaDtor(void* object) {
  RenderAnnotation_FilledOval* _this = reinterpret_cast< RenderAnnotation_FilledOval* >(object);
  (void)_this;
}
void RenderAnnotation_FilledOval::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_FilledOval::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_FilledOval::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.FilledOval)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(oval_ != nullptr);
      oval_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(fill_color_ != nullptr);
      fill_color_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_FilledOval::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .mediapipe.RenderAnnotation.Oval oval = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_oval(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.Color fill_color = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_fill_color(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_FilledOval::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.FilledOval)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .mediapipe.RenderAnnotation.Oval oval = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::oval(this), target, stream);
  }

  // optional .mediapipe.Color fill_color = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::fill_color(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.FilledOval)
  return target;
}

size_t RenderAnnotation_FilledOval::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.FilledOval)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .mediapipe.RenderAnnotation.Oval oval = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *oval_);
    }

    // optional .mediapipe.Color fill_color = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *fill_color_);
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_FilledOval::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_FilledOval::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_FilledOval::GetClassData() const { return &_class_data_; }

void RenderAnnotation_FilledOval::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_FilledOval *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_FilledOval &>(from));
}


void RenderAnnotation_FilledOval::MergeFrom(const RenderAnnotation_FilledOval& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.FilledOval)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_oval()->::mediapipe::RenderAnnotation_Oval::MergeFrom(from._internal_oval());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_fill_color()->::mediapipe::Color::MergeFrom(from._internal_fill_color());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_FilledOval::CopyFrom(const RenderAnnotation_FilledOval& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.FilledOval)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_FilledOval::IsInitialized() const {
  return true;
}

void RenderAnnotation_FilledOval::InternalSwap(RenderAnnotation_FilledOval* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_FilledOval, fill_color_)
      + sizeof(RenderAnnotation_FilledOval::fill_color_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_FilledOval, oval_)>(
          reinterpret_cast<char*>(&oval_),
          reinterpret_cast<char*>(&other->oval_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_FilledOval::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[6]);
}

// ===================================================================

class RenderAnnotation_Point::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_Point>()._has_bits_);
  static void set_has_x(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_y(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_normalized(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

RenderAnnotation_Point::RenderAnnotation_Point(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.Point)
}
RenderAnnotation_Point::RenderAnnotation_Point(const RenderAnnotation_Point& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&x_, &from.x_,
    static_cast<size_t>(reinterpret_cast<char*>(&normalized_) -
    reinterpret_cast<char*>(&x_)) + sizeof(normalized_));
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.Point)
}

inline void RenderAnnotation_Point::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&normalized_) -
    reinterpret_cast<char*>(&x_)) + sizeof(normalized_));
}

RenderAnnotation_Point::~RenderAnnotation_Point() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.Point)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_Point::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void RenderAnnotation_Point::ArenaDtor(void* object) {
  RenderAnnotation_Point* _this = reinterpret_cast< RenderAnnotation_Point* >(object);
  (void)_this;
}
void RenderAnnotation_Point::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_Point::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_Point::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.Point)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&x_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&normalized_) -
        reinterpret_cast<char*>(&x_)) + sizeof(normalized_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_Point::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
          _Internal::set_has_x(&has_bits);
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double y = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_y(&has_bits);
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool normalized = 3 [default = false];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_normalized(&has_bits);
          normalized_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_Point::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.Point)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double x = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_x(), target);
  }

  // optional double y = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_y(), target);
  }

  // optional bool normalized = 3 [default = false];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_normalized(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.Point)
  return target;
}

size_t RenderAnnotation_Point::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.Point)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional double x = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional double y = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

    // optional bool normalized = 3 [default = false];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_Point::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_Point::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_Point::GetClassData() const { return &_class_data_; }

void RenderAnnotation_Point::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_Point *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_Point &>(from));
}


void RenderAnnotation_Point::MergeFrom(const RenderAnnotation_Point& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.Point)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      x_ = from.x_;
    }
    if (cached_has_bits & 0x00000002u) {
      y_ = from.y_;
    }
    if (cached_has_bits & 0x00000004u) {
      normalized_ = from.normalized_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_Point::CopyFrom(const RenderAnnotation_Point& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.Point)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_Point::IsInitialized() const {
  return true;
}

void RenderAnnotation_Point::InternalSwap(RenderAnnotation_Point* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_Point, normalized_)
      + sizeof(RenderAnnotation_Point::normalized_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_Point, x_)>(
          reinterpret_cast<char*>(&x_),
          reinterpret_cast<char*>(&other->x_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_Point::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[7]);
}

// ===================================================================

class RenderAnnotation_Line::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_Line>()._has_bits_);
  static void set_has_x_start(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_y_start(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_x_end(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_y_end(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_normalized(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_line_type(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

RenderAnnotation_Line::RenderAnnotation_Line(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.Line)
}
RenderAnnotation_Line::RenderAnnotation_Line(const RenderAnnotation_Line& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&x_start_, &from.x_start_,
    static_cast<size_t>(reinterpret_cast<char*>(&line_type_) -
    reinterpret_cast<char*>(&x_start_)) + sizeof(line_type_));
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.Line)
}

inline void RenderAnnotation_Line::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&x_start_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&normalized_) -
    reinterpret_cast<char*>(&x_start_)) + sizeof(normalized_));
line_type_ = 1;
}

RenderAnnotation_Line::~RenderAnnotation_Line() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.Line)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_Line::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void RenderAnnotation_Line::ArenaDtor(void* object) {
  RenderAnnotation_Line* _this = reinterpret_cast< RenderAnnotation_Line* >(object);
  (void)_this;
}
void RenderAnnotation_Line::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_Line::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_Line::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.Line)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    ::memset(&x_start_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&normalized_) -
        reinterpret_cast<char*>(&x_start_)) + sizeof(normalized_));
    line_type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_Line::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double x_start = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
          _Internal::set_has_x_start(&has_bits);
          x_start_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double y_start = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_y_start(&has_bits);
          y_start_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double x_end = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_x_end(&has_bits);
          x_end_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double y_end = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 33)) {
          _Internal::set_has_y_end(&has_bits);
          y_end_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool normalized = 5 [default = false];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_normalized(&has_bits);
          normalized_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.RenderAnnotation.Line.LineType line_type = 6 [default = SOLID];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::mediapipe::RenderAnnotation_Line_LineType_IsValid(val))) {
            _internal_set_line_type(static_cast<::mediapipe::RenderAnnotation_Line_LineType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_Line::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.Line)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double x_start = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_x_start(), target);
  }

  // optional double y_start = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_y_start(), target);
  }

  // optional double x_end = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_x_end(), target);
  }

  // optional double y_end = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->_internal_y_end(), target);
  }

  // optional bool normalized = 5 [default = false];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_normalized(), target);
  }

  // optional .mediapipe.RenderAnnotation.Line.LineType line_type = 6 [default = SOLID];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      6, this->_internal_line_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.Line)
  return target;
}

size_t RenderAnnotation_Line::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.Line)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional double x_start = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional double y_start = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

    // optional double x_end = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

    // optional double y_end = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional bool normalized = 5 [default = false];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional .mediapipe.RenderAnnotation.Line.LineType line_type = 6 [default = SOLID];
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_line_type());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_Line::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_Line::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_Line::GetClassData() const { return &_class_data_; }

void RenderAnnotation_Line::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_Line *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_Line &>(from));
}


void RenderAnnotation_Line::MergeFrom(const RenderAnnotation_Line& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.Line)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      x_start_ = from.x_start_;
    }
    if (cached_has_bits & 0x00000002u) {
      y_start_ = from.y_start_;
    }
    if (cached_has_bits & 0x00000004u) {
      x_end_ = from.x_end_;
    }
    if (cached_has_bits & 0x00000008u) {
      y_end_ = from.y_end_;
    }
    if (cached_has_bits & 0x00000010u) {
      normalized_ = from.normalized_;
    }
    if (cached_has_bits & 0x00000020u) {
      line_type_ = from.line_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_Line::CopyFrom(const RenderAnnotation_Line& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.Line)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_Line::IsInitialized() const {
  return true;
}

void RenderAnnotation_Line::InternalSwap(RenderAnnotation_Line* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_Line, normalized_)
      + sizeof(RenderAnnotation_Line::normalized_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_Line, x_start_)>(
          reinterpret_cast<char*>(&x_start_),
          reinterpret_cast<char*>(&other->x_start_));
  swap(line_type_, other->line_type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_Line::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[8]);
}

// ===================================================================

class RenderAnnotation_GradientLine::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_GradientLine>()._has_bits_);
  static void set_has_x_start(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_y_start(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_x_end(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_y_end(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_normalized(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static const ::mediapipe::Color& color1(const RenderAnnotation_GradientLine* msg);
  static void set_has_color1(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::mediapipe::Color& color2(const RenderAnnotation_GradientLine* msg);
  static void set_has_color2(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::mediapipe::Color&
RenderAnnotation_GradientLine::_Internal::color1(const RenderAnnotation_GradientLine* msg) {
  return *msg->color1_;
}
const ::mediapipe::Color&
RenderAnnotation_GradientLine::_Internal::color2(const RenderAnnotation_GradientLine* msg) {
  return *msg->color2_;
}
void RenderAnnotation_GradientLine::clear_color1() {
  if (color1_ != nullptr) color1_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
void RenderAnnotation_GradientLine::clear_color2() {
  if (color2_ != nullptr) color2_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
RenderAnnotation_GradientLine::RenderAnnotation_GradientLine(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.GradientLine)
}
RenderAnnotation_GradientLine::RenderAnnotation_GradientLine(const RenderAnnotation_GradientLine& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_color1()) {
    color1_ = new ::mediapipe::Color(*from.color1_);
  } else {
    color1_ = nullptr;
  }
  if (from._internal_has_color2()) {
    color2_ = new ::mediapipe::Color(*from.color2_);
  } else {
    color2_ = nullptr;
  }
  ::memcpy(&x_start_, &from.x_start_,
    static_cast<size_t>(reinterpret_cast<char*>(&normalized_) -
    reinterpret_cast<char*>(&x_start_)) + sizeof(normalized_));
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.GradientLine)
}

inline void RenderAnnotation_GradientLine::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&color1_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&normalized_) -
    reinterpret_cast<char*>(&color1_)) + sizeof(normalized_));
}

RenderAnnotation_GradientLine::~RenderAnnotation_GradientLine() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.GradientLine)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_GradientLine::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete color1_;
  if (this != internal_default_instance()) delete color2_;
}

void RenderAnnotation_GradientLine::ArenaDtor(void* object) {
  RenderAnnotation_GradientLine* _this = reinterpret_cast< RenderAnnotation_GradientLine* >(object);
  (void)_this;
}
void RenderAnnotation_GradientLine::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_GradientLine::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_GradientLine::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.GradientLine)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(color1_ != nullptr);
      color1_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(color2_ != nullptr);
      color2_->Clear();
    }
  }
  if (cached_has_bits & 0x0000007cu) {
    ::memset(&x_start_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&normalized_) -
        reinterpret_cast<char*>(&x_start_)) + sizeof(normalized_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_GradientLine::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double x_start = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
          _Internal::set_has_x_start(&has_bits);
          x_start_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double y_start = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_y_start(&has_bits);
          y_start_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double x_end = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_x_end(&has_bits);
          x_end_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double y_end = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 33)) {
          _Internal::set_has_y_end(&has_bits);
          y_end_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool normalized = 5 [default = false];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_normalized(&has_bits);
          normalized_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.Color color1 = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_color1(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.Color color2 = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_color2(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_GradientLine::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.GradientLine)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double x_start = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_x_start(), target);
  }

  // optional double y_start = 2;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_y_start(), target);
  }

  // optional double x_end = 3;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_x_end(), target);
  }

  // optional double y_end = 4;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->_internal_y_end(), target);
  }

  // optional bool normalized = 5 [default = false];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_normalized(), target);
  }

  // optional .mediapipe.Color color1 = 6;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::color1(this), target, stream);
  }

  // optional .mediapipe.Color color2 = 7;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::color2(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.GradientLine)
  return target;
}

size_t RenderAnnotation_GradientLine::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.GradientLine)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    // optional .mediapipe.Color color1 = 6;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *color1_);
    }

    // optional .mediapipe.Color color2 = 7;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *color2_);
    }

    // optional double x_start = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

    // optional double y_start = 2;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional double x_end = 3;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 8;
    }

    // optional double y_end = 4;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 8;
    }

    // optional bool normalized = 5 [default = false];
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 1;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_GradientLine::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_GradientLine::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_GradientLine::GetClassData() const { return &_class_data_; }

void RenderAnnotation_GradientLine::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_GradientLine *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_GradientLine &>(from));
}


void RenderAnnotation_GradientLine::MergeFrom(const RenderAnnotation_GradientLine& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.GradientLine)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_color1()->::mediapipe::Color::MergeFrom(from._internal_color1());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_color2()->::mediapipe::Color::MergeFrom(from._internal_color2());
    }
    if (cached_has_bits & 0x00000004u) {
      x_start_ = from.x_start_;
    }
    if (cached_has_bits & 0x00000008u) {
      y_start_ = from.y_start_;
    }
    if (cached_has_bits & 0x00000010u) {
      x_end_ = from.x_end_;
    }
    if (cached_has_bits & 0x00000020u) {
      y_end_ = from.y_end_;
    }
    if (cached_has_bits & 0x00000040u) {
      normalized_ = from.normalized_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_GradientLine::CopyFrom(const RenderAnnotation_GradientLine& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.GradientLine)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_GradientLine::IsInitialized() const {
  return true;
}

void RenderAnnotation_GradientLine::InternalSwap(RenderAnnotation_GradientLine* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_GradientLine, normalized_)
      + sizeof(RenderAnnotation_GradientLine::normalized_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_GradientLine, color1_)>(
          reinterpret_cast<char*>(&color1_),
          reinterpret_cast<char*>(&other->color1_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_GradientLine::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[9]);
}

// ===================================================================

class RenderAnnotation_Scribble::_Internal {
 public:
};

RenderAnnotation_Scribble::RenderAnnotation_Scribble(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  point_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.Scribble)
}
RenderAnnotation_Scribble::RenderAnnotation_Scribble(const RenderAnnotation_Scribble& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      point_(from.point_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.Scribble)
}

inline void RenderAnnotation_Scribble::SharedCtor() {
}

RenderAnnotation_Scribble::~RenderAnnotation_Scribble() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.Scribble)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_Scribble::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void RenderAnnotation_Scribble::ArenaDtor(void* object) {
  RenderAnnotation_Scribble* _this = reinterpret_cast< RenderAnnotation_Scribble* >(object);
  (void)_this;
}
void RenderAnnotation_Scribble::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_Scribble::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_Scribble::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.Scribble)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  point_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_Scribble::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .mediapipe.RenderAnnotation.Point point = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_point(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_Scribble::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.Scribble)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .mediapipe.RenderAnnotation.Point point = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_point_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_point(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.Scribble)
  return target;
}

size_t RenderAnnotation_Scribble::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.Scribble)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .mediapipe.RenderAnnotation.Point point = 1;
  total_size += 1UL * this->_internal_point_size();
  for (const auto& msg : this->point_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_Scribble::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_Scribble::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_Scribble::GetClassData() const { return &_class_data_; }

void RenderAnnotation_Scribble::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_Scribble *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_Scribble &>(from));
}


void RenderAnnotation_Scribble::MergeFrom(const RenderAnnotation_Scribble& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.Scribble)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  point_.MergeFrom(from.point_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_Scribble::CopyFrom(const RenderAnnotation_Scribble& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.Scribble)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_Scribble::IsInitialized() const {
  return true;
}

void RenderAnnotation_Scribble::InternalSwap(RenderAnnotation_Scribble* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  point_.InternalSwap(&other->point_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_Scribble::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[10]);
}

// ===================================================================

class RenderAnnotation_Arrow::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_Arrow>()._has_bits_);
  static void set_has_x_start(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_y_start(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_x_end(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_y_end(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_normalized(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

RenderAnnotation_Arrow::RenderAnnotation_Arrow(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.Arrow)
}
RenderAnnotation_Arrow::RenderAnnotation_Arrow(const RenderAnnotation_Arrow& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&x_start_, &from.x_start_,
    static_cast<size_t>(reinterpret_cast<char*>(&normalized_) -
    reinterpret_cast<char*>(&x_start_)) + sizeof(normalized_));
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.Arrow)
}

inline void RenderAnnotation_Arrow::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&x_start_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&normalized_) -
    reinterpret_cast<char*>(&x_start_)) + sizeof(normalized_));
}

RenderAnnotation_Arrow::~RenderAnnotation_Arrow() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.Arrow)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_Arrow::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void RenderAnnotation_Arrow::ArenaDtor(void* object) {
  RenderAnnotation_Arrow* _this = reinterpret_cast< RenderAnnotation_Arrow* >(object);
  (void)_this;
}
void RenderAnnotation_Arrow::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_Arrow::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_Arrow::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.Arrow)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    ::memset(&x_start_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&normalized_) -
        reinterpret_cast<char*>(&x_start_)) + sizeof(normalized_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_Arrow::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double x_start = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
          _Internal::set_has_x_start(&has_bits);
          x_start_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double y_start = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_y_start(&has_bits);
          y_start_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double x_end = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_x_end(&has_bits);
          x_end_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double y_end = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 33)) {
          _Internal::set_has_y_end(&has_bits);
          y_end_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool normalized = 5 [default = false];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_normalized(&has_bits);
          normalized_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_Arrow::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.Arrow)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double x_start = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_x_start(), target);
  }

  // optional double y_start = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_y_start(), target);
  }

  // optional double x_end = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_x_end(), target);
  }

  // optional double y_end = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->_internal_y_end(), target);
  }

  // optional bool normalized = 5 [default = false];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_normalized(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.Arrow)
  return target;
}

size_t RenderAnnotation_Arrow::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.Arrow)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional double x_start = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional double y_start = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

    // optional double x_end = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

    // optional double y_end = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional bool normalized = 5 [default = false];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_Arrow::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_Arrow::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_Arrow::GetClassData() const { return &_class_data_; }

void RenderAnnotation_Arrow::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_Arrow *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_Arrow &>(from));
}


void RenderAnnotation_Arrow::MergeFrom(const RenderAnnotation_Arrow& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.Arrow)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      x_start_ = from.x_start_;
    }
    if (cached_has_bits & 0x00000002u) {
      y_start_ = from.y_start_;
    }
    if (cached_has_bits & 0x00000004u) {
      x_end_ = from.x_end_;
    }
    if (cached_has_bits & 0x00000008u) {
      y_end_ = from.y_end_;
    }
    if (cached_has_bits & 0x00000010u) {
      normalized_ = from.normalized_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_Arrow::CopyFrom(const RenderAnnotation_Arrow& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.Arrow)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_Arrow::IsInitialized() const {
  return true;
}

void RenderAnnotation_Arrow::InternalSwap(RenderAnnotation_Arrow* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_Arrow, normalized_)
      + sizeof(RenderAnnotation_Arrow::normalized_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_Arrow, x_start_)>(
          reinterpret_cast<char*>(&x_start_),
          reinterpret_cast<char*>(&other->x_start_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_Arrow::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[11]);
}

// ===================================================================

class RenderAnnotation_Text::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation_Text>()._has_bits_);
  static void set_has_display_text(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_left(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_baseline(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_font_height(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_normalized(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_font_face(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_center_horizontally(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_center_vertically(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_outline_thickness(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static const ::mediapipe::Color& outline_color(const RenderAnnotation_Text* msg);
  static void set_has_outline_color(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::mediapipe::Color&
RenderAnnotation_Text::_Internal::outline_color(const RenderAnnotation_Text* msg) {
  return *msg->outline_color_;
}
void RenderAnnotation_Text::clear_outline_color() {
  if (outline_color_ != nullptr) outline_color_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
RenderAnnotation_Text::RenderAnnotation_Text(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation.Text)
}
RenderAnnotation_Text::RenderAnnotation_Text(const RenderAnnotation_Text& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  display_text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    display_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_display_text()) {
    display_text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_display_text(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_outline_color()) {
    outline_color_ = new ::mediapipe::Color(*from.outline_color_);
  } else {
    outline_color_ = nullptr;
  }
  ::memcpy(&left_, &from.left_,
    static_cast<size_t>(reinterpret_cast<char*>(&font_height_) -
    reinterpret_cast<char*>(&left_)) + sizeof(font_height_));
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation.Text)
}

inline void RenderAnnotation_Text::SharedCtor() {
display_text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  display_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&outline_color_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&outline_thickness_) -
    reinterpret_cast<char*>(&outline_color_)) + sizeof(outline_thickness_));
font_height_ = 8;
}

RenderAnnotation_Text::~RenderAnnotation_Text() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation.Text)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation_Text::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  display_text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete outline_color_;
}

void RenderAnnotation_Text::ArenaDtor(void* object) {
  RenderAnnotation_Text* _this = reinterpret_cast< RenderAnnotation_Text* >(object);
  (void)_this;
}
void RenderAnnotation_Text::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation_Text::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation_Text::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation.Text)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      display_text_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(outline_color_ != nullptr);
      outline_color_->Clear();
    }
  }
  if (cached_has_bits & 0x000000fcu) {
    ::memset(&left_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&center_vertically_) -
        reinterpret_cast<char*>(&left_)) + sizeof(center_vertically_));
  }
  if (cached_has_bits & 0x00000300u) {
    outline_thickness_ = 0;
    font_height_ = 8;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation_Text::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string display_text = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_display_text();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.RenderAnnotation.Text.display_text");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double left = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_left(&has_bits);
          left_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double baseline = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_baseline(&has_bits);
          baseline_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double font_height = 4 [default = 8];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 33)) {
          _Internal::set_has_font_height(&has_bits);
          font_height_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool normalized = 5 [default = false];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_normalized(&has_bits);
          normalized_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 font_face = 6 [default = 0];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          _Internal::set_has_font_face(&has_bits);
          font_face_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool center_horizontally = 7 [default = false];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          _Internal::set_has_center_horizontally(&has_bits);
          center_horizontally_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool center_vertically = 8 [default = false];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _Internal::set_has_center_vertically(&has_bits);
          center_vertically_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double outline_thickness = 11 [default = 0];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 89)) {
          _Internal::set_has_outline_thickness(&has_bits);
          outline_thickness_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.Color outline_color = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_outline_color(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation_Text::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation.Text)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string display_text = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_display_text().data(), static_cast<int>(this->_internal_display_text().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "mediapipe.RenderAnnotation.Text.display_text");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_display_text(), target);
  }

  // optional double left = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_left(), target);
  }

  // optional double baseline = 3;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_baseline(), target);
  }

  // optional double font_height = 4 [default = 8];
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->_internal_font_height(), target);
  }

  // optional bool normalized = 5 [default = false];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_normalized(), target);
  }

  // optional int32 font_face = 6 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_font_face(), target);
  }

  // optional bool center_horizontally = 7 [default = false];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_center_horizontally(), target);
  }

  // optional bool center_vertically = 8 [default = false];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_center_vertically(), target);
  }

  // optional double outline_thickness = 11 [default = 0];
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(11, this->_internal_outline_thickness(), target);
  }

  // optional .mediapipe.Color outline_color = 12;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        12, _Internal::outline_color(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation.Text)
  return target;
}

size_t RenderAnnotation_Text::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation.Text)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string display_text = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_display_text());
    }

    // optional .mediapipe.Color outline_color = 12;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *outline_color_);
    }

    // optional double left = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

    // optional double baseline = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional int32 font_face = 6 [default = 0];
    if (cached_has_bits & 0x00000010u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_font_face());
    }

    // optional bool normalized = 5 [default = false];
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

    // optional bool center_horizontally = 7 [default = false];
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 1;
    }

    // optional bool center_vertically = 8 [default = false];
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 + 1;
    }

  }
  if (cached_has_bits & 0x00000300u) {
    // optional double outline_thickness = 11 [default = 0];
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 + 8;
    }

    // optional double font_height = 4 [default = 8];
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 + 8;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation_Text::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation_Text::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation_Text::GetClassData() const { return &_class_data_; }

void RenderAnnotation_Text::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation_Text *>(to)->MergeFrom(
      static_cast<const RenderAnnotation_Text &>(from));
}


void RenderAnnotation_Text::MergeFrom(const RenderAnnotation_Text& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation.Text)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_display_text(from._internal_display_text());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_outline_color()->::mediapipe::Color::MergeFrom(from._internal_outline_color());
    }
    if (cached_has_bits & 0x00000004u) {
      left_ = from.left_;
    }
    if (cached_has_bits & 0x00000008u) {
      baseline_ = from.baseline_;
    }
    if (cached_has_bits & 0x00000010u) {
      font_face_ = from.font_face_;
    }
    if (cached_has_bits & 0x00000020u) {
      normalized_ = from.normalized_;
    }
    if (cached_has_bits & 0x00000040u) {
      center_horizontally_ = from.center_horizontally_;
    }
    if (cached_has_bits & 0x00000080u) {
      center_vertically_ = from.center_vertically_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000300u) {
    if (cached_has_bits & 0x00000100u) {
      outline_thickness_ = from.outline_thickness_;
    }
    if (cached_has_bits & 0x00000200u) {
      font_height_ = from.font_height_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation_Text::CopyFrom(const RenderAnnotation_Text& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation.Text)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation_Text::IsInitialized() const {
  return true;
}

void RenderAnnotation_Text::InternalSwap(RenderAnnotation_Text* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &display_text_, lhs_arena,
      &other->display_text_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderAnnotation_Text, outline_thickness_)
      + sizeof(RenderAnnotation_Text::outline_thickness_)
      - PROTOBUF_FIELD_OFFSET(RenderAnnotation_Text, outline_color_)>(
          reinterpret_cast<char*>(&outline_color_),
          reinterpret_cast<char*>(&other->outline_color_));
  swap(font_height_, other->font_height_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation_Text::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[12]);
}

// ===================================================================

class RenderAnnotation::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderAnnotation>()._has_bits_);
  static const ::mediapipe::RenderAnnotation_Rectangle& rectangle(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_FilledRectangle& filled_rectangle(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_Oval& oval(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_FilledOval& filled_oval(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_Point& point(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_Line& line(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_Arrow& arrow(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_Text& text(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_RoundedRectangle& rounded_rectangle(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_FilledRoundedRectangle& filled_rounded_rectangle(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_GradientLine& gradient_line(const RenderAnnotation* msg);
  static const ::mediapipe::RenderAnnotation_Scribble& scribble(const RenderAnnotation* msg);
  static void set_has_thickness(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::mediapipe::Color& color(const RenderAnnotation* msg);
  static void set_has_color(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_scene_tag(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::mediapipe::RenderAnnotation_Rectangle&
RenderAnnotation::_Internal::rectangle(const RenderAnnotation* msg) {
  return *msg->data_.rectangle_;
}
const ::mediapipe::RenderAnnotation_FilledRectangle&
RenderAnnotation::_Internal::filled_rectangle(const RenderAnnotation* msg) {
  return *msg->data_.filled_rectangle_;
}
const ::mediapipe::RenderAnnotation_Oval&
RenderAnnotation::_Internal::oval(const RenderAnnotation* msg) {
  return *msg->data_.oval_;
}
const ::mediapipe::RenderAnnotation_FilledOval&
RenderAnnotation::_Internal::filled_oval(const RenderAnnotation* msg) {
  return *msg->data_.filled_oval_;
}
const ::mediapipe::RenderAnnotation_Point&
RenderAnnotation::_Internal::point(const RenderAnnotation* msg) {
  return *msg->data_.point_;
}
const ::mediapipe::RenderAnnotation_Line&
RenderAnnotation::_Internal::line(const RenderAnnotation* msg) {
  return *msg->data_.line_;
}
const ::mediapipe::RenderAnnotation_Arrow&
RenderAnnotation::_Internal::arrow(const RenderAnnotation* msg) {
  return *msg->data_.arrow_;
}
const ::mediapipe::RenderAnnotation_Text&
RenderAnnotation::_Internal::text(const RenderAnnotation* msg) {
  return *msg->data_.text_;
}
const ::mediapipe::RenderAnnotation_RoundedRectangle&
RenderAnnotation::_Internal::rounded_rectangle(const RenderAnnotation* msg) {
  return *msg->data_.rounded_rectangle_;
}
const ::mediapipe::RenderAnnotation_FilledRoundedRectangle&
RenderAnnotation::_Internal::filled_rounded_rectangle(const RenderAnnotation* msg) {
  return *msg->data_.filled_rounded_rectangle_;
}
const ::mediapipe::RenderAnnotation_GradientLine&
RenderAnnotation::_Internal::gradient_line(const RenderAnnotation* msg) {
  return *msg->data_.gradient_line_;
}
const ::mediapipe::RenderAnnotation_Scribble&
RenderAnnotation::_Internal::scribble(const RenderAnnotation* msg) {
  return *msg->data_.scribble_;
}
const ::mediapipe::Color&
RenderAnnotation::_Internal::color(const RenderAnnotation* msg) {
  return *msg->color_;
}
void RenderAnnotation::set_allocated_rectangle(::mediapipe::RenderAnnotation_Rectangle* rectangle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (rectangle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_Rectangle>::GetOwningArena(rectangle);
    if (message_arena != submessage_arena) {
      rectangle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rectangle, submessage_arena);
    }
    set_has_rectangle();
    data_.rectangle_ = rectangle;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.rectangle)
}
void RenderAnnotation::set_allocated_filled_rectangle(::mediapipe::RenderAnnotation_FilledRectangle* filled_rectangle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (filled_rectangle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_FilledRectangle>::GetOwningArena(filled_rectangle);
    if (message_arena != submessage_arena) {
      filled_rectangle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, filled_rectangle, submessage_arena);
    }
    set_has_filled_rectangle();
    data_.filled_rectangle_ = filled_rectangle;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.filled_rectangle)
}
void RenderAnnotation::set_allocated_oval(::mediapipe::RenderAnnotation_Oval* oval) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (oval) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_Oval>::GetOwningArena(oval);
    if (message_arena != submessage_arena) {
      oval = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, oval, submessage_arena);
    }
    set_has_oval();
    data_.oval_ = oval;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.oval)
}
void RenderAnnotation::set_allocated_filled_oval(::mediapipe::RenderAnnotation_FilledOval* filled_oval) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (filled_oval) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_FilledOval>::GetOwningArena(filled_oval);
    if (message_arena != submessage_arena) {
      filled_oval = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, filled_oval, submessage_arena);
    }
    set_has_filled_oval();
    data_.filled_oval_ = filled_oval;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.filled_oval)
}
void RenderAnnotation::set_allocated_point(::mediapipe::RenderAnnotation_Point* point) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (point) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_Point>::GetOwningArena(point);
    if (message_arena != submessage_arena) {
      point = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, point, submessage_arena);
    }
    set_has_point();
    data_.point_ = point;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.point)
}
void RenderAnnotation::set_allocated_line(::mediapipe::RenderAnnotation_Line* line) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (line) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_Line>::GetOwningArena(line);
    if (message_arena != submessage_arena) {
      line = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, line, submessage_arena);
    }
    set_has_line();
    data_.line_ = line;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.line)
}
void RenderAnnotation::set_allocated_arrow(::mediapipe::RenderAnnotation_Arrow* arrow) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (arrow) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_Arrow>::GetOwningArena(arrow);
    if (message_arena != submessage_arena) {
      arrow = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arrow, submessage_arena);
    }
    set_has_arrow();
    data_.arrow_ = arrow;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.arrow)
}
void RenderAnnotation::set_allocated_text(::mediapipe::RenderAnnotation_Text* text) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (text) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_Text>::GetOwningArena(text);
    if (message_arena != submessage_arena) {
      text = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, text, submessage_arena);
    }
    set_has_text();
    data_.text_ = text;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.text)
}
void RenderAnnotation::set_allocated_rounded_rectangle(::mediapipe::RenderAnnotation_RoundedRectangle* rounded_rectangle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (rounded_rectangle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_RoundedRectangle>::GetOwningArena(rounded_rectangle);
    if (message_arena != submessage_arena) {
      rounded_rectangle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rounded_rectangle, submessage_arena);
    }
    set_has_rounded_rectangle();
    data_.rounded_rectangle_ = rounded_rectangle;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.rounded_rectangle)
}
void RenderAnnotation::set_allocated_filled_rounded_rectangle(::mediapipe::RenderAnnotation_FilledRoundedRectangle* filled_rounded_rectangle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (filled_rounded_rectangle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_FilledRoundedRectangle>::GetOwningArena(filled_rounded_rectangle);
    if (message_arena != submessage_arena) {
      filled_rounded_rectangle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, filled_rounded_rectangle, submessage_arena);
    }
    set_has_filled_rounded_rectangle();
    data_.filled_rounded_rectangle_ = filled_rounded_rectangle;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.filled_rounded_rectangle)
}
void RenderAnnotation::set_allocated_gradient_line(::mediapipe::RenderAnnotation_GradientLine* gradient_line) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (gradient_line) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_GradientLine>::GetOwningArena(gradient_line);
    if (message_arena != submessage_arena) {
      gradient_line = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, gradient_line, submessage_arena);
    }
    set_has_gradient_line();
    data_.gradient_line_ = gradient_line;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.gradient_line)
}
void RenderAnnotation::set_allocated_scribble(::mediapipe::RenderAnnotation_Scribble* scribble) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_data();
  if (scribble) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::RenderAnnotation_Scribble>::GetOwningArena(scribble);
    if (message_arena != submessage_arena) {
      scribble = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scribble, submessage_arena);
    }
    set_has_scribble();
    data_.scribble_ = scribble;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.RenderAnnotation.scribble)
}
void RenderAnnotation::clear_color() {
  if (color_ != nullptr) color_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
RenderAnnotation::RenderAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderAnnotation)
}
RenderAnnotation::RenderAnnotation(const RenderAnnotation& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  scene_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    scene_tag_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_scene_tag()) {
    scene_tag_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_scene_tag(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_color()) {
    color_ = new ::mediapipe::Color(*from.color_);
  } else {
    color_ = nullptr;
  }
  thickness_ = from.thickness_;
  clear_has_data();
  switch (from.data_case()) {
    case kRectangle: {
      _internal_mutable_rectangle()->::mediapipe::RenderAnnotation_Rectangle::MergeFrom(from._internal_rectangle());
      break;
    }
    case kFilledRectangle: {
      _internal_mutable_filled_rectangle()->::mediapipe::RenderAnnotation_FilledRectangle::MergeFrom(from._internal_filled_rectangle());
      break;
    }
    case kOval: {
      _internal_mutable_oval()->::mediapipe::RenderAnnotation_Oval::MergeFrom(from._internal_oval());
      break;
    }
    case kFilledOval: {
      _internal_mutable_filled_oval()->::mediapipe::RenderAnnotation_FilledOval::MergeFrom(from._internal_filled_oval());
      break;
    }
    case kPoint: {
      _internal_mutable_point()->::mediapipe::RenderAnnotation_Point::MergeFrom(from._internal_point());
      break;
    }
    case kLine: {
      _internal_mutable_line()->::mediapipe::RenderAnnotation_Line::MergeFrom(from._internal_line());
      break;
    }
    case kArrow: {
      _internal_mutable_arrow()->::mediapipe::RenderAnnotation_Arrow::MergeFrom(from._internal_arrow());
      break;
    }
    case kText: {
      _internal_mutable_text()->::mediapipe::RenderAnnotation_Text::MergeFrom(from._internal_text());
      break;
    }
    case kRoundedRectangle: {
      _internal_mutable_rounded_rectangle()->::mediapipe::RenderAnnotation_RoundedRectangle::MergeFrom(from._internal_rounded_rectangle());
      break;
    }
    case kFilledRoundedRectangle: {
      _internal_mutable_filled_rounded_rectangle()->::mediapipe::RenderAnnotation_FilledRoundedRectangle::MergeFrom(from._internal_filled_rounded_rectangle());
      break;
    }
    case kGradientLine: {
      _internal_mutable_gradient_line()->::mediapipe::RenderAnnotation_GradientLine::MergeFrom(from._internal_gradient_line());
      break;
    }
    case kScribble: {
      _internal_mutable_scribble()->::mediapipe::RenderAnnotation_Scribble::MergeFrom(from._internal_scribble());
      break;
    }
    case DATA_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderAnnotation)
}

inline void RenderAnnotation::SharedCtor() {
scene_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  scene_tag_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
color_ = nullptr;
thickness_ = 1;
clear_has_data();
}

RenderAnnotation::~RenderAnnotation() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderAnnotation)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderAnnotation::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  scene_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete color_;
  if (has_data()) {
    clear_data();
  }
}

void RenderAnnotation::ArenaDtor(void* object) {
  RenderAnnotation* _this = reinterpret_cast< RenderAnnotation* >(object);
  (void)_this;
}
void RenderAnnotation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderAnnotation::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderAnnotation::clear_data() {
// @@protoc_insertion_point(one_of_clear_start:mediapipe.RenderAnnotation)
  switch (data_case()) {
    case kRectangle: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.rectangle_;
      }
      break;
    }
    case kFilledRectangle: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.filled_rectangle_;
      }
      break;
    }
    case kOval: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.oval_;
      }
      break;
    }
    case kFilledOval: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.filled_oval_;
      }
      break;
    }
    case kPoint: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.point_;
      }
      break;
    }
    case kLine: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.line_;
      }
      break;
    }
    case kArrow: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.arrow_;
      }
      break;
    }
    case kText: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.text_;
      }
      break;
    }
    case kRoundedRectangle: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.rounded_rectangle_;
      }
      break;
    }
    case kFilledRoundedRectangle: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.filled_rounded_rectangle_;
      }
      break;
    }
    case kGradientLine: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.gradient_line_;
      }
      break;
    }
    case kScribble: {
      if (GetArenaForAllocation() == nullptr) {
        delete data_.scribble_;
      }
      break;
    }
    case DATA_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = DATA_NOT_SET;
}


void RenderAnnotation::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderAnnotation)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      scene_tag_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(color_ != nullptr);
      color_->Clear();
    }
    thickness_ = 1;
  }
  clear_data();
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderAnnotation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_rectangle(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.FilledRectangle filled_rectangle = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_filled_rectangle(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.Oval oval = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_oval(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.FilledOval filled_oval = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_filled_oval(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.Point point = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_point(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.Line line = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_line(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.Arrow arrow = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_arrow(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.Text text = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_text(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.RoundedRectangle rounded_rectangle = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_rounded_rectangle(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.FilledRoundedRectangle filled_rounded_rectangle = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_filled_rounded_rectangle(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double thickness = 11 [default = 1];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 89)) {
          _Internal::set_has_thickness(&has_bits);
          thickness_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.Color color = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_color(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string scene_tag = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
          auto str = _internal_mutable_scene_tag();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.RenderAnnotation.scene_tag");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.GradientLine gradient_line = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_gradient_line(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.RenderAnnotation.Scribble scribble = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
          ptr = ctx->ParseMessage(_internal_mutable_scribble(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderAnnotation::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderAnnotation)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (data_case()) {
    case kRectangle: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::rectangle(this), target, stream);
      break;
    }
    case kFilledRectangle: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          2, _Internal::filled_rectangle(this), target, stream);
      break;
    }
    case kOval: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::oval(this), target, stream);
      break;
    }
    case kFilledOval: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          4, _Internal::filled_oval(this), target, stream);
      break;
    }
    case kPoint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          5, _Internal::point(this), target, stream);
      break;
    }
    case kLine: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          6, _Internal::line(this), target, stream);
      break;
    }
    case kArrow: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          7, _Internal::arrow(this), target, stream);
      break;
    }
    case kText: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          8, _Internal::text(this), target, stream);
      break;
    }
    case kRoundedRectangle: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          9, _Internal::rounded_rectangle(this), target, stream);
      break;
    }
    case kFilledRoundedRectangle: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          10, _Internal::filled_rounded_rectangle(this), target, stream);
      break;
    }
    default: ;
  }
  cached_has_bits = _has_bits_[0];
  // optional double thickness = 11 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(11, this->_internal_thickness(), target);
  }

  // optional .mediapipe.Color color = 12;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        12, _Internal::color(this), target, stream);
  }

  // optional string scene_tag = 13;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_scene_tag().data(), static_cast<int>(this->_internal_scene_tag().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "mediapipe.RenderAnnotation.scene_tag");
    target = stream->WriteStringMaybeAliased(
        13, this->_internal_scene_tag(), target);
  }

  switch (data_case()) {
    case kGradientLine: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          14, _Internal::gradient_line(this), target, stream);
      break;
    }
    case kScribble: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          15, _Internal::scribble(this), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderAnnotation)
  return target;
}

size_t RenderAnnotation::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderAnnotation)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string scene_tag = 13;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_scene_tag());
    }

    // optional .mediapipe.Color color = 12;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *color_);
    }

    // optional double thickness = 11 [default = 1];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

  }
  switch (data_case()) {
    // .mediapipe.RenderAnnotation.Rectangle rectangle = 1;
    case kRectangle: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.rectangle_);
      break;
    }
    // .mediapipe.RenderAnnotation.FilledRectangle filled_rectangle = 2;
    case kFilledRectangle: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.filled_rectangle_);
      break;
    }
    // .mediapipe.RenderAnnotation.Oval oval = 3;
    case kOval: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.oval_);
      break;
    }
    // .mediapipe.RenderAnnotation.FilledOval filled_oval = 4;
    case kFilledOval: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.filled_oval_);
      break;
    }
    // .mediapipe.RenderAnnotation.Point point = 5;
    case kPoint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.point_);
      break;
    }
    // .mediapipe.RenderAnnotation.Line line = 6;
    case kLine: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.line_);
      break;
    }
    // .mediapipe.RenderAnnotation.Arrow arrow = 7;
    case kArrow: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.arrow_);
      break;
    }
    // .mediapipe.RenderAnnotation.Text text = 8;
    case kText: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.text_);
      break;
    }
    // .mediapipe.RenderAnnotation.RoundedRectangle rounded_rectangle = 9;
    case kRoundedRectangle: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.rounded_rectangle_);
      break;
    }
    // .mediapipe.RenderAnnotation.FilledRoundedRectangle filled_rounded_rectangle = 10;
    case kFilledRoundedRectangle: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.filled_rounded_rectangle_);
      break;
    }
    // .mediapipe.RenderAnnotation.GradientLine gradient_line = 14;
    case kGradientLine: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.gradient_line_);
      break;
    }
    // .mediapipe.RenderAnnotation.Scribble scribble = 15;
    case kScribble: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *data_.scribble_);
      break;
    }
    case DATA_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderAnnotation::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderAnnotation::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderAnnotation::GetClassData() const { return &_class_data_; }

void RenderAnnotation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderAnnotation *>(to)->MergeFrom(
      static_cast<const RenderAnnotation &>(from));
}


void RenderAnnotation::MergeFrom(const RenderAnnotation& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderAnnotation)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_scene_tag(from._internal_scene_tag());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_color()->::mediapipe::Color::MergeFrom(from._internal_color());
    }
    if (cached_has_bits & 0x00000004u) {
      thickness_ = from.thickness_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.data_case()) {
    case kRectangle: {
      _internal_mutable_rectangle()->::mediapipe::RenderAnnotation_Rectangle::MergeFrom(from._internal_rectangle());
      break;
    }
    case kFilledRectangle: {
      _internal_mutable_filled_rectangle()->::mediapipe::RenderAnnotation_FilledRectangle::MergeFrom(from._internal_filled_rectangle());
      break;
    }
    case kOval: {
      _internal_mutable_oval()->::mediapipe::RenderAnnotation_Oval::MergeFrom(from._internal_oval());
      break;
    }
    case kFilledOval: {
      _internal_mutable_filled_oval()->::mediapipe::RenderAnnotation_FilledOval::MergeFrom(from._internal_filled_oval());
      break;
    }
    case kPoint: {
      _internal_mutable_point()->::mediapipe::RenderAnnotation_Point::MergeFrom(from._internal_point());
      break;
    }
    case kLine: {
      _internal_mutable_line()->::mediapipe::RenderAnnotation_Line::MergeFrom(from._internal_line());
      break;
    }
    case kArrow: {
      _internal_mutable_arrow()->::mediapipe::RenderAnnotation_Arrow::MergeFrom(from._internal_arrow());
      break;
    }
    case kText: {
      _internal_mutable_text()->::mediapipe::RenderAnnotation_Text::MergeFrom(from._internal_text());
      break;
    }
    case kRoundedRectangle: {
      _internal_mutable_rounded_rectangle()->::mediapipe::RenderAnnotation_RoundedRectangle::MergeFrom(from._internal_rounded_rectangle());
      break;
    }
    case kFilledRoundedRectangle: {
      _internal_mutable_filled_rounded_rectangle()->::mediapipe::RenderAnnotation_FilledRoundedRectangle::MergeFrom(from._internal_filled_rounded_rectangle());
      break;
    }
    case kGradientLine: {
      _internal_mutable_gradient_line()->::mediapipe::RenderAnnotation_GradientLine::MergeFrom(from._internal_gradient_line());
      break;
    }
    case kScribble: {
      _internal_mutable_scribble()->::mediapipe::RenderAnnotation_Scribble::MergeFrom(from._internal_scribble());
      break;
    }
    case DATA_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderAnnotation::CopyFrom(const RenderAnnotation& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderAnnotation)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderAnnotation::IsInitialized() const {
  return true;
}

void RenderAnnotation::InternalSwap(RenderAnnotation* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &scene_tag_, lhs_arena,
      &other->scene_tag_, rhs_arena
  );
  swap(color_, other->color_);
  swap(thickness_, other->thickness_);
  swap(data_, other->data_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderAnnotation::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[13]);
}

// ===================================================================

class RenderViewport::_Internal {
 public:
  using HasBits = decltype(std::declval<RenderViewport>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_width_px(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_height_px(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_compose_on_video(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

RenderViewport::RenderViewport(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.RenderViewport)
}
RenderViewport::RenderViewport(const RenderViewport& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_id()) {
    id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_id(), 
      GetArenaForAllocation());
  }
  ::memcpy(&width_px_, &from.width_px_,
    static_cast<size_t>(reinterpret_cast<char*>(&compose_on_video_) -
    reinterpret_cast<char*>(&width_px_)) + sizeof(compose_on_video_));
  // @@protoc_insertion_point(copy_constructor:mediapipe.RenderViewport)
}

inline void RenderViewport::SharedCtor() {
id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&width_px_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&compose_on_video_) -
    reinterpret_cast<char*>(&width_px_)) + sizeof(compose_on_video_));
}

RenderViewport::~RenderViewport() {
  // @@protoc_insertion_point(destructor:mediapipe.RenderViewport)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RenderViewport::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RenderViewport::ArenaDtor(void* object) {
  RenderViewport* _this = reinterpret_cast< RenderViewport* >(object);
  (void)_this;
}
void RenderViewport::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RenderViewport::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RenderViewport::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.RenderViewport)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    id_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000000eu) {
    ::memset(&width_px_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&compose_on_video_) -
        reinterpret_cast<char*>(&width_px_)) + sizeof(compose_on_video_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RenderViewport::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.RenderViewport.id");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 width_px = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _Internal::set_has_width_px(&has_bits);
          width_px_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 height_px = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_height_px(&has_bits);
          height_px_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool compose_on_video = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_compose_on_video(&has_bits);
          compose_on_video_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* RenderViewport::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.RenderViewport)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "mediapipe.RenderViewport.id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_id(), target);
  }

  // optional int32 width_px = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_width_px(), target);
  }

  // optional int32 height_px = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_height_px(), target);
  }

  // optional bool compose_on_video = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_compose_on_video(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.RenderViewport)
  return target;
}

size_t RenderViewport::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.RenderViewport)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional string id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_id());
    }

    // optional int32 width_px = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_width_px());
    }

    // optional int32 height_px = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_height_px());
    }

    // optional bool compose_on_video = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RenderViewport::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RenderViewport::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RenderViewport::GetClassData() const { return &_class_data_; }

void RenderViewport::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RenderViewport *>(to)->MergeFrom(
      static_cast<const RenderViewport &>(from));
}


void RenderViewport::MergeFrom(const RenderViewport& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.RenderViewport)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_id(from._internal_id());
    }
    if (cached_has_bits & 0x00000002u) {
      width_px_ = from.width_px_;
    }
    if (cached_has_bits & 0x00000004u) {
      height_px_ = from.height_px_;
    }
    if (cached_has_bits & 0x00000008u) {
      compose_on_video_ = from.compose_on_video_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RenderViewport::CopyFrom(const RenderViewport& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.RenderViewport)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RenderViewport::IsInitialized() const {
  return true;
}

void RenderViewport::InternalSwap(RenderViewport* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &id_, lhs_arena,
      &other->id_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RenderViewport, compose_on_video_)
      + sizeof(RenderViewport::compose_on_video_)
      - PROTOBUF_FIELD_OFFSET(RenderViewport, width_px_)>(
          reinterpret_cast<char*>(&width_px_),
          reinterpret_cast<char*>(&other->width_px_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RenderViewport::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_getter, &descriptor_table_mediapipe_2futil_2frender_5fdata_2eproto_once,
      file_level_metadata_mediapipe_2futil_2frender_5fdata_2eproto[14]);
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace mediapipe
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::mediapipe::RenderData* Arena::CreateMaybeMessage< ::mediapipe::RenderData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderData >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_Rectangle* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_Rectangle >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_Rectangle >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_FilledRectangle* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_FilledRectangle >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_FilledRectangle >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_RoundedRectangle* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_RoundedRectangle >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_RoundedRectangle >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_FilledRoundedRectangle* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_FilledRoundedRectangle >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_FilledRoundedRectangle >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_Oval* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_Oval >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_Oval >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_FilledOval* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_FilledOval >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_FilledOval >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_Point* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_Point >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_Point >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_Line* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_Line >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_Line >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_GradientLine* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_GradientLine >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_GradientLine >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_Scribble* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_Scribble >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_Scribble >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_Arrow* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_Arrow >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_Arrow >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation_Text* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation_Text >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation_Text >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderAnnotation* Arena::CreateMaybeMessage< ::mediapipe::RenderAnnotation >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderAnnotation >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::RenderViewport* Arena::CreateMaybeMessage< ::mediapipe::RenderViewport >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::RenderViewport >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>