%begin %{

#define PY_SSIZE_T_CLEAN

%}

%pythoncode %{

def fromstring(data, mappath=None, configpath=None):

"""Creates map objects from mapfile strings.

>>> mo = fromstring("MAP\nNAME 'test'\nEND")

import re

if re.search(r"^\s*MAP", data, re.I):

# create a config object if a path is supplied

if configpath:

config = configObj(configpath)

else:

config = None

return msLoadMapFromString(data, mappath, config)

elif re.search(r"^\s*LAYER", data, re.I):

ob = layerObj()

ob.updateFromString(data)

return ob

elif re.search(r"^\s*CLASS", data, re.I):

ob = classObj()

ob.updateFromString(data)

return ob

elif re.search(r"^\s*STYLE", data, re.I):

ob = styleObj()

ob.updateFromString(data)

return ob

else:

raise ValueError("No map, layer, class, or style found. Can not load from provided string")

%}

%extend rectObj {

%pythoncode %{

def __str__(self):

return self.toString()

def __contains__(self, item):

item_type = item.__class__.__name__

if item_type == "pointObj":

if item.x >= self.minx and item.x <= self.maxx \

and item.y >= self.miny and item.y <= self.maxy:

return True

else:

return False

else:

raise TypeError('__contains__ does not yet handle %s' % (item_type))

%}

}

%extend pointObj {

%pythoncode %{

def __str__(self):

return self.toString()

@property

def __geo_interface__(self):

if hasattr(self, "z"):

coords = (self.x, self.y, self.z)

else:

coords = (self.x, self.y)

return {"type": "Point", "coordinates": coords}

%}

}

%extend lineObj {

%pythoncode %{

@property

def __geo_interface__(self):

coords = []

for idx in range(0, self.numpoints):

pt = self.get(idx)

geom = pt.__geo_interface__

coords.append(geom["coordinates"])

return {"type": "LineString", "coordinates": coords}

%}

}

%extend shapeObj {

%pythoncode %{

def _convert_item_values(self, property_values, property_types):

"""

typed_values = []

for value, type_ in zip(property_values, property_types):

try:

if type_.lower() == "integer":

value = int(value)

elif type_.lower() == "long":

value = long(value)

elif type_.lower() == "real":

value = float(value)

else:

pass

except ValueError:

pass

typed_values.append(value)

return typed_values

@property

def __geo_interface__(self):

bounds = self.bounds

ms_geom_type = self.type

# see https://tools.ietf.org/html/rfc7946 for GeoJSON types

if ms_geom_type == MS_SHAPE_POINT or ms_geom_type == MS_SHP_POINTZ or ms_geom_type == MS_SHP_POINTM:

geom_type = "Point"

elif ms_geom_type == MS_SHP_MULTIPOINTZ or ms_geom_type == MS_SHP_MULTIPOINTM:

geom_type = "MultiPoint"

elif ms_geom_type == MS_SHAPE_LINE or ms_geom_type == MS_SHP_ARCZ or ms_geom_type == MS_SHP_ARCM:

if self.numlines == 1:

geom_type = "LineString"

else:

geom_type = "MultiLineString"

elif ms_geom_type == MS_SHAPE_POLYGON or ms_geom_type == MS_SHP_POLYGONZ or ms_geom_type == MS_SHP_POLYGONM:

if self.numlines == 1:

geom_type = "Polygon"

else:

geom_type = "MultiPolygon"

elif ms_geom_type == MS_SHAPE_NULL:

return None

else:

raise TypeError("Shape type {} not supported".format(geom_type))

properties = {}

coords = []

# property names are stored at the layer level

# https://github.com/mapserver/mapserver/issues/130

property_values = [self.getValue(idx) for idx in range(0, self.numvalues)]

if hasattr(self, "_item_definitions"):

property_names, property_types = zip(*self._item_definitions)

property_values = self._convert_item_values(property_values, property_types)

else:

property_names = [str(idx) for idx in range(0, self.numvalues)]

properties = dict(zip(property_names, property_values))

for idx in range(0, self.numlines):

line = self.get(idx)

geom = line.__geo_interface__

coords.append(geom["coordinates"])

return {

"type": "Feature",

"bbox": (bounds.minx, bounds.miny, bounds.maxx, bounds.maxy),

"properties": properties,

"geometry": {

"type": geom_type,

"coordinates": coords

}

}

@property

def itemdefinitions(self):

return self._item_definitions

@itemdefinitions.setter

def itemdefinitions(self, item_definitions):

self._item_definitions = item_definitions

%}

}

%extend mapObj {

/**

PyObject *getLayerOrder() {

int i;

PyObject *order;

order = PyTuple_New(self->numlayers);

for (i = 0; i < self->numlayers; i++) {

PyTuple_SetItem(order,i,PyInt_FromLong((long)self->layerorder[i]));

}

return order;

}

/**

int setLayerOrder(PyObject *order) {

int i;

Py_ssize_t size = PyTuple_Size(order);

for (i = 0; i < size; i++) {

self->layerorder[i] = (int)PyInt_AsLong(PyTuple_GetItem(order, i));

}

return MS_SUCCESS;

}

/**

PyObject* getSize()

{

PyObject* output ;

output = PyTuple_New(2);

PyTuple_SetItem(output,0,PyInt_FromLong((long)self->width));

PyTuple_SetItem(output,1,PyInt_FromLong((long)self->height));

return output;

}

%pythoncode %{

def get_height(self):

"""

return self.getSize()[1] # <-- second member is the height

def get_width(self):

"""

return self.getSize()[0] # <-- first member is the width

def set_height(self, value):

"""

return self.setSize(self.getSize()[0], value)

def set_width(self, value):

"""

return self.setSize(value, self.getSize()[1])

width = property(get_width, set_width, doc="See :ref:`SIZE <mapfile-map-size>`")

height = property(get_height, set_height, doc = "See :ref:`SIZE <mapfile-map-size>`")

%}

}

%extend layerObj {

%pythoncode %{

def getItemDefinitions(self):

"""

item_names = [self.getItem(idx) for idx in range(0, self.numitems)]

item_types = [self.getItemType(idx) for idx in range(0, self.numitems)]

return zip(item_names, item_types)

%}

}

%extend imageObj {

/**

int write( PyObject *file=Py_None )

{

unsigned char *imgbuffer=NULL;

int imgsize;

PyObject *noerr;

int retval=MS_FAILURE;

/* Return immediately if image driver is not GD */

if ( !MS_RENDERER_PLUGIN(self->format) )

{

msSetError(MS_IMGERR, "Writing of %s format not implemented",

"imageObj::write", self->format->driver);

return MS_FAILURE;

}

if (file == Py_None) /* write to stdout */

retval = msSaveImage(NULL, self, NULL);

else /* presume a Python file-like object */

{

imgbuffer = msSaveImageBuffer(self, &imgsize,

self->format);

if (imgsize == 0)

{

msSetError(MS_IMGERR, "failed to get image buffer", "write()");

return MS_FAILURE;

}

%#if PY_MAJOR_VERSION >= 3

// https://docs.python.org/3/c-api/arg.html

noerr = PyObject_CallMethod(file, "write", "y#", imgbuffer, (Py_ssize_t)imgsize);

%#else

// https://docs.python.org/2/c-api/arg.html

noerr = PyObject_CallMethod(file, "write", "s#", imgbuffer, imgsize);

%#endif

free(imgbuffer);

if (noerr == NULL)

return MS_FAILURE;

else

Py_DECREF(noerr);

retval = MS_SUCCESS;

}

return retval;

}

}

%extend styleObj {

/// **Python Only** Set the pattern for the style.

void pattern_set(int nListSize, double* pListValues)

{

if( nListSize < 2 )

{

msSetError(MS_SYMERR, "Not enough pattern elements. A minimum of 2 are required", "pattern_set()");

return;

}

if( nListSize > MS_MAXPATTERNLENGTH )

{

msSetError(MS_MISCERR, "Too many elements", "pattern_set()");

return;

}

memcpy( self->pattern, pListValues, sizeof(double) * nListSize);

self->patternlength = nListSize;

}

/// **Python Only** Get the pattern for the style.

void pattern_get(double** argout, int* pnListSize)

{

*pnListSize = self->patternlength;

*argout = (double*) malloc(sizeof(double) * *pnListSize);

memcpy( *argout, self->pattern, sizeof(double) * *pnListSize);

}

%pythoncode %{

pattern = property(pattern_get, pattern_set, doc=r"""pattern : list **Python Only**""")

%}

}

%extend hashTableObj{

%pythoncode %{

def __getitem__(self, key):

return self.get(key)

def __setitem__(self, key, value):

return self.set(key, value)

def __delitem__(self, key) :

return self.remove(key)

def __contains__(self, key):

return key.lower() in [k.lower() for k in self.keys()]

def __len__(self):

return self.numitems

def keys(self):

"""

keys = []

k = None

while True :

k = self.nextKey(k)

if k :

keys.append(k)

else :

break

return keys

%}

}