%{

#include <memory>

#include <sstream>

#include <string>

#include "s2/s2boolean_operation.h"

#include "s2/s2buffer_operation.h"

#include "s2/s2builder.h"

#include "s2/s2builder_layer.h"

#include "s2/s2builderutil_s2polygon_layer.h"

#include "s2/s2cell_id.h"

#include "s2/s2region.h"

#include "s2/s2cap.h"

#include "s2/s2edge_crossings.h"

#include "s2/s2edge_distances.h"

#include "s2/s2earth.h"

#include "s2/s2latlng.h"

#include "s2/s2latlng_rect.h"

#include "s2/s2loop.h"

#include "s2/s2measures.h"

#include "s2/s2pointutil.h"

#include "s2/s2polygon.h"

#include "s2/s2polyline.h"

#include "s2/s2predicates.h"

#include "s2/s2region_coverer.h"

#include "s2/s2region_term_indexer.h"

#include "s2/s2cell.h"

#include "s2/s2cell_union.h"

#include "s2/s2shape_index.h"

#include "s2/mutable_s2shape_index.h"

class S2BufferOperationOptions {

S2BufferOperation::Options opts;

void set_buffer_radius(S1Angle buffer_radius) {

opts.set_buffer_radius(buffer_radius);

}

void set_error_fraction(double error_fraction) {

opts.set_error_fraction(error_fraction);

}

};

class S2PolygonLayerOptions {

s2builderutil::S2PolygonLayer::Options opts;

void set_edge_type(S2Builder::EdgeType edge_type) {

opts.set_edge_type(edge_type);

}

};

%}

%inline %{

static PyObject *FromS2CellId(const S2CellId &cell_id) {

return SWIG_NewPointerObj(new S2CellId(cell_id), SWIGTYPE_p_S2CellId,

SWIG_POINTER_OWN);

}

%}

%apply std::vector<S2CellId> *OUTPUT {std::vector<S2CellId> *covering};

%apply std::vector<S2CellId> *OUTPUT {std::vector<S2CellId> *interior};

%apply std::vector<S2CellId> *OUTPUT {std::vector<S2CellId> *output};

%typemap(in, numinputs=0) S2CellId *OUTPUT_ARRAY_4(S2CellId temp[4]) {

$1 = temp;

}

%typemap(out) std::pair<double, double> {

$result = Py_BuildValue("dd", $1.first, $1.second);

}

%typemap(argout) S2CellId *OUTPUT_ARRAY_4 {

$result = PyList_New(4);

if ($result == nullptr) return nullptr;

for (int i = 0; i < 4; i++) {

PyObject *const o = FromS2CellId($1[i]);

if (!o) {

Py_DECREF($result);

return nullptr;

}

PyList_SET_ITEM($result, i, o);

}

}

%apply S2CellId *OUTPUT_ARRAY_4 {S2CellId neighbors[4]};

%typemap(in, numinputs=0) S2Error * (S2Error err) {

$1 = &err;

}

%typemap(argout) S2Error * {

if(!$1->ok())

SWIG_exception(SWIG_ValueError, std::string($1->message()).c_str());

}

%ignore S2CellUnion::Init(std::vector<S2CellId> const& cell_ids);

%extend S2Polyline {

public:

void InitFromS2LatLngs(const std::vector<S2LatLng>& vertices) {

$self->Init(absl::MakeConstSpan(vertices));

}

void InitFromS2Points(const std::vector<S2Point>& vertices) {

$self->Init(absl::MakeConstSpan(vertices));

}

};

%rename(NormalizeS2CellUnion) S2CellUnion::Normalize();

%apply int *OUTPUT {int *next_vertex};

%apply int *OUTPUT {int *psi};

%apply int *OUTPUT {int *pti};

%apply int *OUTPUT {int *pi};

%apply int *OUTPUT {int *pj};

%apply int *OUTPUT {int *orientation};

%apply SWIGTYPE *DISOWN {S2Loop *loop_disown};

%apply SWIGTYPE *DISOWN {S2Builder::Layer *layer_disown};

%apply SWIGTYPE *DISOWN {S2Polygon *polygon_disown};

%typemap(in) std::vector<S2Loop *> * (std::vector<S2Loop *> loops) {

PyObject *iter = PyObject_GetIter($input);

if (iter == nullptr) {

%argument_fail(SWIG_TypeError, "iterable of S2Loop *", $symname, $argnum);

}

for (PyObject *elem; (elem = PyIter_Next(iter)); Py_DECREF(elem)) {

S2Loop *loop = nullptr;

int res = SWIG_ConvertPtr(

elem, reinterpret_cast<void **>(&loop), $descriptor(S2Loop *),

SWIG_POINTER_NO_NULL);

if (!SWIG_IsOK(res)) {

Py_DECREF(elem);

Py_DECREF(iter);

for (S2Loop *loop : loops) delete loop;

%argument_fail(res, "$type", $symname, $argnum);

}

loops.push_back(new S2Loop(*loop));

}

Py_DECREF(iter);

$1 = &loops;

}

%typemap(in, numinputs=0)

std::vector<S2Polyline *> *out(std::vector<S2Polyline *> temp) {

$1 = &temp;

}

%typemap(argout) std::vector<S2Polyline *> *out {

$result = PyList_New($1->size());

if ($result == nullptr) return nullptr;

for (int i = 0; i < $1->size(); i++) {

PyObject *const o =

SWIG_NewPointerObj((*$1)[i], $descriptor(S2Polyline *), SWIG_POINTER_OWN);

if (!o) {

Py_DECREF($result);

return nullptr;

}

PyList_SET_ITEM($result, i, o);

}

}

%inline %{

// This isn't a constructor because it clashes with the SWIG-redefinition

// below and the actual S2Point (a Vector_3d).

static PyObject *S2Point_FromRaw(double x, double y, double z) {

// Creates an S2Point directly, mostly useful for testing.

return SWIG_NewPointerObj(new S2Point(x, y, z), SWIGTYPE_p_S2Point,

SWIG_POINTER_OWN);

}

static PyObject *S2Point_ToRaw(const S2Point& p) {

return Py_BuildValue("ddd", p[0], p[1], p[2]);

}

%}

class S2Point {

public:

double x();

double y();

double z();

double Norm();

S2Point Normalize();

~S2Point();

};

%extend S2Loop {

public:

S2LatLng GetS2LatLngVertex(int i) {

return S2LatLng($self->vertex(i));

}

};

%extend S2Cell {

public:

S2LatLng GetS2LatLngVertex(int k) {

return S2LatLng($self->GetVertex(k));

}

};

%extend S2Cell {

public:

S2LatLng GetS2LatLngEdge(int k) {

return S2LatLng($self->GetEdge(k));

}

};

%extend S2Loop {

public:

explicit S2Loop(const std::vector<S2Point>& vertices) {

return new S2Loop(absl::MakeConstSpan(vertices));

}

void Init(const std::vector<S2Point>& vertices) {

$self->Init(absl::MakeConstSpan(vertices));

}

};

%extend S2Polygon {

public:

// Takes ownership of the loop. The _disown suffix is used to tell SWIG

// that S2Polygon takes ownership of the loop.

explicit S2Polygon(S2Loop* loop_disown) {

// SWIG recognizes this as a constructor, but implements this

// as a free function, so write it that way.

return new S2Polygon(std::unique_ptr<S2Loop>(loop_disown));

}

void InitNested(std::vector<S2Loop*>* loops) {

std::vector<std::unique_ptr<S2Loop>> unique_loops(loops->size());

for (int i = 0; i < loops->size(); ++i) {

unique_loops[i].reset((*loops)[i]);

}

loops->clear();

$self->InitNested(std::move(unique_loops));

}

void IntersectWithPolyline(S2Polyline const* in,

std::vector<S2Polyline*>* out) const {

std::vector<std::unique_ptr<S2Polyline>> polylines =

$self->IntersectWithPolyline(*in);

ABSL_DCHECK(out->empty());

out->reserve(polylines.size());

for (auto& polyline : polylines) {

out->push_back(polyline.release());

}

}

}

%extend S2Builder {

public:

void StartLayer(S2Builder::Layer* layer_disown) {

$self->StartLayer(std::unique_ptr<S2Builder::Layer>(layer_disown));

}

}

class S2PolygonLayerOptions {

s2builderutil::S2PolygonLayer::Options opts;

void set_edge_type(S2Builder::EdgeType);

};

%pythonprepend s2builderutil::S2PolygonLayer::S2PolygonLayer %{

self._incref = args[0]

%}

%extend s2builderutil::S2PolygonLayer {

public:

S2PolygonLayer(S2Polygon* layer,

const S2PolygonLayerOptions& options) {

return new s2builderutil::S2PolygonLayer(layer, options.opts);

}

}

%extend MutableS2ShapeIndex {

public:

void Add(S2Polygon* polygon_disown) {

auto polygon = std::unique_ptr<S2Polygon>(polygon_disown);

$self->Add(std::unique_ptr<S2Shape>(new S2Polygon::OwningShape(std::move(polygon))));

}

}

%extend S2BooleanOperation {

public:

S2BooleanOperation(OpType op_type,

S2Builder::Layer* layer_disown) {

S2BooleanOperation::Options options;

auto layer = std::unique_ptr<S2Builder::Layer>(layer_disown);

return new S2BooleanOperation(op_type, std::move(layer), options);

}

}

class S2BufferOperationOptions {

S2BufferOperation::Options opts;

void set_buffer_radius(S1Angle);

void set_error_fraction(double);

};

%extend S2BufferOperation {

public:

S2BufferOperation(S2Builder::Layer* layer_disown) {

auto layer = std::unique_ptr<S2Builder::Layer>(layer_disown);

return new S2BufferOperation(std::move(layer));

}

S2BufferOperation(S2Builder::Layer* layer_disown,

const S2BufferOperationOptions& options) {

auto layer = std::unique_ptr<S2Builder::Layer>(layer_disown);

return new S2BufferOperation(std::move(layer), options.opts);

}

void AddPolygon(S2Polygon* polygon_disown) {

auto polygon = std::unique_ptr<S2Polygon>(polygon_disown);

$self->AddShape(S2Polygon::OwningShape(std::move(polygon)));

}

void AddPoint(S2Point& point) {

$self->AddPoint(point);

}

}

%extend S2RegionCoverer {

int max_cells() const { return $self->options().max_cells(); }

void set_max_cells(int max_cells) {

$self->mutable_options()->set_max_cells(max_cells);

}

int min_level() const { return $self->options().min_level(); }

void set_min_level(int min_level) {

$self->mutable_options()->set_min_level(min_level);

}

int max_level() const { return $self->options().max_level(); }

void set_max_level(int max_level) {

$self->mutable_options()->set_max_level(max_level);

}

void set_fixed_level(int fixed_level) {

$self->mutable_options()->set_fixed_level(fixed_level);

}

int level_mod() const { return $self->options().level_mod(); }

void set_level_mod(int level_mod) {

$self->mutable_options()->set_level_mod(level_mod);

}

int true_max_level() const { return $self->options().true_max_level(); }

}

%extend S2RegionTermIndexer {

int max_cells() const { return $self->options().max_cells(); }

void set_max_cells(int max_cells) {

$self->mutable_options()->set_max_cells(max_cells);

}

int min_level() const { return $self->options().min_level(); }

void set_min_level(int min_level) {

$self->mutable_options()->set_min_level(min_level);

}

int max_level() const { return $self->options().max_level(); }

void set_max_level(int max_level) {

$self->mutable_options()->set_max_level(max_level);

}

void set_fixed_level(int fixed_level) {

$self->mutable_options()->set_fixed_level(fixed_level);

}

int level_mod() const { return $self->options().level_mod(); }

void set_level_mod(int level_mod) {

$self->mutable_options()->set_level_mod(level_mod);

}

int true_max_level() const { return $self->options().true_max_level(); }

bool index_contains_points_only() const {

return $self->options().index_contains_points_only();

}

void set_index_contains_points_only(bool value) {

$self->mutable_options()->set_index_contains_points_only(value);

}

bool optimize_for_space() const {

return $self->options().optimize_for_space();

}

void set_optimize_for_space(bool value) {

$self->mutable_options()->set_optimize_for_space(value);

}

char marker_character() const { return $self->options().marker_character(); }

void set_marker_character(char ch) {

$self->mutable_options()->set_marker_character(ch);

}

}

%copyctor S1ChordAngle;

%pythonprepend S2CellId::child %{

if not self.is_valid():

raise ValueError("S2CellId must be valid.")

if self.is_leaf():

raise ValueError("S2CellId must be non-leaf.")

if not 0 <= position < 4:

raise ValueError("Position must be 0-3.")

%}

%pythonprepend S2CellId::child_position(int) const %{

if not self.is_valid():

raise ValueError("S2CellId must be valid.")

if level < 1 or level > self.level():

raise ValueError("level must must be in range [1, S2 cell level]")

%}

%pythonprepend S2CellId::contains %{

if not self.is_valid() or not other.is_valid():

raise ValueError("Both S2CellIds must be valid.")

%}

%pythonprepend S2CellId::intersects %{

if not self.is_valid() or not other.is_valid():

raise ValueError("Both S2CellIds must be valid.")

%}

%pythonprepend S2CellId::level %{

# As in the C++ version:

# We can't just check is_valid() because we want level() to be

raise ValueError("Level must be less than or equal to cell's level.")

%include "s2/r1interval.h"

%include "s2/s1angle.h"

%include "s2/s1chord_angle.h"

%include "s2/s1interval.h"

%include "s2/s2boolean_operation.h"

%include "s2/s2buffer_operation.h"

%include "s2/s2builder.h"

%include "s2/s2builder_layer.h"

%include "s2/s2builderutil_s2polygon_layer.h"

%include "s2/s2cell_id.h"

%include "s2/s2edge_crossings.h"

%include "s2/s2edge_distances.h"

%include "s2/s2earth.h"

%include "s2/s2region.h"

%include "s2/s2cap.h"

%include "s2/s2latlng.h"

%include "s2/s2latlng_rect.h"

%include "s2/s2loop.h"

%include "s2/s2measures.h"

%include "s2/s2pointutil.h"

%include "s2/s2polygon.h"

%include "s2/s2polyline.h"

%include "s2/s2predicates.h"

%include "s2/s2region_coverer.h"

%include "s2/s2region_term_indexer.h"

%include "s2/s2cell.h"

%include "s2/s2cell_union.h"

%include "s2/s2shape_index.h"

%include "s2/mutable_s2shape_index.h"