int convert_dashes(PyObject *dashobj, void *dashesp)
{
    Dashes *dashes = (Dashes *)dashesp;

    if (dashobj == NULL && dashobj == Py_None) {
        return 1;
    }

    PyObject *dash_offset_obj = NULL;
    double dash_offset = 0.0;
    PyObject *dashes_seq = NULL;
    Py_ssize_t nentries;

    if (!PyArg_ParseTuple(dashobj, "OO:dashes", &dash_offset_obj, &dashes_seq)) {
        return 0;
    }

    if (dash_offset_obj != Py_None) {
        dash_offset = PyFloat_AsDouble(dash_offset_obj);
        if (PyErr_Occurred()) {
            return 0;
        }
    }

    if (dashes_seq == Py_None) {
        return 1;
    }

    if (!PySequence_Check(dashes_seq)) {
        PyErr_SetString(PyExc_TypeError, "Invalid dashes sequence");
        return 0;
    }

    nentries = PySequence_Size(dashes_seq);
    if (nentries % 2 != 0) {
        PyErr_Format(PyExc_ValueError, "dashes sequence must have an even number of elements");
        return 0;
    }

    for (Py_ssize_t i = 0; i < nentries; ++i) {
        PyObject *item;
        double length;
        double skip;

        item = PySequence_GetItem(dashes_seq, i);
        if (item == NULL) {
            return 0;
        }
        length = PyFloat_AsDouble(item);
        if (PyErr_Occurred()) {
            Py_DECREF(item);
            return 0;
        }
        Py_DECREF(item);

        ++i;

        item = PySequence_GetItem(dashes_seq, i);
        if (item == NULL) {
            return 0;
        }
        skip = PyFloat_AsDouble(item);
        if (PyErr_Occurred()) {
            Py_DECREF(item);
            return 0;
        }
        Py_DECREF(item);

        dashes->add_dash_pair(length, skip);
    }

    dashes->set_dash_offset(dash_offset);

    return 1;
}
static polypaths_planar_overridePolygonObject *
Poly_create_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *verts_arg, *is_convex_arg = NULL, *is_simple_arg = NULL;
	PyObject *verts_seq = NULL;
	polypaths_planar_overridePolygonObject *poly = NULL;
	Py_ssize_t size, i;

    static char *kwlist[] = {"vertices", "is_convex", "is_simple", NULL};

    if (!PyArg_ParseTupleAndKeywords(
        args, kwargs, "O|OO:Polygon.__init__", kwlist, 
			&verts_arg, &is_convex_arg, &is_simple_arg)) {
        return NULL;
    }
	if (!PySequence_Check(verts_arg)) {
		verts_arg = verts_seq = PySequence_Fast(verts_arg, 
			"expected iterable of Vec2 objects");
		if (verts_seq == NULL) {
			goto error;
		}
	}
	size = PySequence_Size(verts_arg);
	if (size == -1) {
		goto error;
	}
	poly = Poly_new(type, size);
	if (poly == NULL) {
		goto error;
	}
	if ((is_convex_arg != NULL && PyObject_IsTrue(is_convex_arg) > 0)
		|| size == 3) {
		poly->flags = (POLY_CONVEX_FLAG | POLY_CONVEX_KNOWN_FLAG 
			| POLY_SIMPLE_FLAG | POLY_SIMPLE_KNOWN_FLAG);
	} else if (is_simple_arg != NULL && PyObject_IsTrue(is_simple_arg) > 0) {
		poly->flags = POLY_SIMPLE_FLAG | POLY_SIMPLE_KNOWN_FLAG;
	}

    if (polypaths_planar_overrideSeq2_Check(verts_arg)) {
		/* Copy existing Seq2 (optimized) */
		memcpy(poly->vert, ((polypaths_planar_overrideSeq2Object *)verts_arg)->vec, 
			sizeof(polypaths_planar_override_vec2_t) * size);
    } else {
		/* Generic iterable of points */
		for (i = 0; i < size; ++i) {
			if (!polypaths_planar_overrideVec2_Parse(PySequence_Fast_GET_ITEM(verts_arg, i), 
				&poly->vert[i].x, &poly->vert[i].y)) {
				PyErr_SetString(PyExc_TypeError,
					"expected iterable of Vec2 objects");
				goto error;
			}
		}
    }
	Py_XDECREF(verts_seq);
	return poly;

error:
	Py_XDECREF(verts_seq);
	Py_XDECREF(poly);
	return NULL;
}
Beispiel #3
0
void PyLink::setTranslationAxis(PyObject *v)
{
    if (PySequence_Size(v) != 3) return;
    PyListToVector(v, d);
}
void TileEngine::renderTilesLazy(
    cairo_t *ctx,
    PyObject *tileFunction,
    PyObject *tileMap,
    int tileSize,
    int renderCol,
    int renderRow,
    int renderCols,
    int renderRows,
    double alpha,
    PyObject *tileGenerator,
    PyObject *tileCache,
    PyObject *tileCacheSurfaces,
    PyObject *tileState)
{
    if ((tileFunction != Py_None) &&
	!PyCallable_Check(tileFunction)) {
	PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileFunction to be a callable function or None");
	return;
    }

    // The tileMap should be None, or an array of 4 byte integers,
    // mapping virtual tiles indices to absolute tile numbers.

    const int *tileMapData = NULL;
    unsigned int tileMapCount = 0;

    if (tileMap != Py_None) {

      if (!PySequence_Check(tileMap)) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap to be an array "
		"of 4 byte integers or None");
	    return;
	}

	tileMapCount = (unsigned int)PySequence_Size(tileMap);
	Py_ssize_t tileMapLength = 0;
	if (PyObject_AsReadBuffer(
	    tileMap,
	    (const void **)&tileMapData,
	    &tileMapLength) != 0) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap with read buffer");
	    return;
	}

	int tileMapDataCount = 
	    (int)tileMapLength / sizeof(unsigned int);

	if (tileMapDataCount != (int)tileMapCount) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap read buffer of 4 byte integers");
	    return;
	}
    }

    // The tileGenerator should be a function that takes one integer
    // tile parameter, and returns a tuple of three integers: a
    // surface index, a tileX and a tileY position.
    if (!PyCallable_Check(tileGenerator)) {
	PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileGenerator callable object");
	return;
    }

    // The tileCache should be an array of integers, 4 integers per
    // tile.  The first is a "cached" flag, the second is a surface
    // index, the 3rd and 4th are a tileX and tileY position.

    int *tileCacheData = NULL;
    Py_ssize_t tileCacheLength = 0;

    if (PyObject_AsWriteBuffer(
	tileCache,
	(void **)&tileCacheData,
	&tileCacheLength) != 0) {
	PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileCache array");
	return;
    }

    // The tileCacheSurfaces parameters should be a list of Cairo
    // surfaces.
    if (!PySequence_Check(tileCacheSurfaces)) {
	PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileCacheSurfaces sequence");
	return;
    }

    // The tileState parameters should be None or a list of tile state
    // parameters.
    if ((tileState != Py_None) &&
	!PySequence_Check(tileState)) {
	PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileState sequence or None");
	return;
    }

    int renderX = renderCol * tileSize;
    int renderY = renderRow * tileSize;

    int r;
    for (r = 0; r < renderRows; r++) {
	int c;
	for (c = 0; c  < renderCols; c++) {
	    int col = (renderCol + c) % width;
	    int row = (renderRow + r) % height;

	    unsigned long tile = 
		getValue(
		    col,
		    row,
		    tileFunction,
		    tileMapData,
		    tileMapCount);

	    double x = col * tileSize;
	    double y = row * tileSize;

	    // Get the tile surface index, tileX and tileY from the
	    // cache, or call the tileGenerator function to produce
	    // them, if they are not already cached.

	    int cacheOffset = tile * 4;
	    int tileSurfaceIndex = 0;
	    int tileX = 0;
	    int tileY = 0;

	    if (tileCacheData[cacheOffset + 0]) {

		// The tile is already cached. 
		// Get the values from the tileCache. 

		tileSurfaceIndex = tileCacheData[cacheOffset + 1];
		tileX = tileCacheData[cacheOffset + 2];
		tileY = tileCacheData[cacheOffset + 3];

	    } else {

		// The tile has not already been cached.  Call the
		// tileGenerator function to produce the tile, passing
		// it the absolute tile number as a parameter.

		// Mark the tile as cached, so we don't do this again. 
		tileCacheData[cacheOffset + 0] = 1;

		PyObject *result =
		    PyObject_CallFunction(
			tileGenerator,
			"i",
			tile);

		// The tile function returns a tuple of three numbers:
		// the surface index (into the tileCacheSurfaces array
		// of Cairo surfaces), the tileX and tileY position in
		// the surface.

		if (result == NULL) {
		    PyErr_SetString(
			PyExc_TypeError,
			"tile generator did not return a result");
		    return;
		}

		int success =
		    PyArg_ParseTuple(
			result,
			"iii",
			&tileSurfaceIndex,
			&tileX,
			&tileY);
		Py_DECREF(result);
		if (!success) {
		    PyErr_SetString(
			PyExc_TypeError,
			"tile generator return wrong number of "
		        "results in tuple");
		    return;
		}

		// Cache the returned values. 
		tileCacheData[cacheOffset + 1] = tileSurfaceIndex;
		tileCacheData[cacheOffset + 2] = tileX;
		tileCacheData[cacheOffset + 3] = tileY;
	    }

	    // Get the Python object wrapping the Cairo surface for
	    // the tile.
	    PyObject *tiles =
		PySequence_GetItem(
		    tileCacheSurfaces,
		    tileSurfaceIndex);

	    if (tiles == NULL) {
		PyErr_SetString(
		    PyExc_TypeError,
		    "tile generator returned invalid tile "
		    "surface index");
		return;
	    }

	    if (!PyObject_TypeCheck(
		  tiles,
		  &PycairoSurface_Type)) {
		PyErr_SetString(
		    PyExc_TypeError,
		    "expected cairo_surface_t objects "
		    "in tileCacheSurfaces");
		return;
	    }

	    // Get the cairo_surface_t from the Python object.
	    cairo_surface_t *tilesSurf = PycairoSurface_GET(tiles);
	    Py_DECREF(tiles);

	    // Draw a tile.

	    cairo_save(ctx);

	    cairo_translate(
		ctx,
		x - renderX,
		y - renderY);

	    cairo_rectangle(
		ctx,
		0,
		0,
		tileSize,
		tileSize);

	    cairo_clip(ctx);

	    cairo_set_source_surface(
		ctx,
		tilesSurf,
		-tileX,
		-tileY);

	    if (alpha >= 1.0) {
		cairo_paint(ctx);
	    } else {
		cairo_paint_with_alpha(ctx, alpha);
	    }

	    cairo_restore(ctx);
	}
    }
}
PyObject *TileEngine::getTileData(
    PyObject *tileFunction,
    PyObject *tileMap,
    int col,
    int row,
    int cols,
    int rows,
    int code,
    PyObject *tileViewCache)
{
    if ((tileFunction != Py_None) &&
	!PyCallable_Check(tileFunction)) {
	PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileFunction to be a callable function or None");
	Py_INCREF(Py_None);
	return Py_None;
    }

    const int *tileMapData = NULL;
    unsigned int tileMapCount = 0;

    if (tileMap != Py_None) {

        if (!PySequence_Check(tileMap)) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap to be an array "
		"of 4 byte integers or None");
	    Py_INCREF(Py_None);
	    return Py_None;
	}

	tileMapCount = (unsigned int)PySequence_Size(tileMap);
	Py_ssize_t tileMapLength = 0;
	if (PyObject_AsReadBuffer(
	    tileMap,
	    (const void **)&tileMapData,
	    &tileMapLength) != 0) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap with read buffer");
	    Py_INCREF(Py_None);
	    return Py_None;
	}

	int tileMapDataCount = 
	    (int)tileMapLength / sizeof(unsigned int);

	if (tileMapDataCount != (int)tileMapCount) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap read buffer of 4 byte integers");
	    Py_INCREF(Py_None);
	    return Py_None;
	}
    }

    int *tileViewCacheData = NULL;
    int tileViewCacheCount = 0;

    if (tileViewCache != Py_None) {
	tileViewCacheCount =
	    (unsigned int)PySequence_Size(tileViewCache);
	Py_ssize_t tileViewCacheLength = 0;
	if ((tileViewCacheCount != (width * height)) ||
	    (PyObject_AsWriteBuffer(
	       tileViewCache,
	       (void **)&tileViewCacheData,
	       &tileViewCacheLength) != 0)) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileViewCache with write buffer");
	    Py_INCREF(Py_None);
	    return Py_None;
	}
    }

    const char *textCodeString =
	"0123456789"
        "abcdefghijklmnopqrstuvwxyz"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ+-";
    int tileSize = sizeof(unsigned short);
    int r, c;
    int bufSize = 0;
    char *buf = NULL;
    bool returnBuffer = false;

    switch (code) {

	case TILE_CODE_RAW_BINARY_16: {
	    bufSize = tileSize * rows * cols;
	    buf = (char *)malloc(bufSize);
	    unsigned char *dst = (unsigned char *)buf;

	    for (r = 0; r < rows; r++) {
		for (c = 0; c < cols; c++) {
		    int tile = 
			getValue(
			    col + c, 
			    row + r, 
			    tileFunction, 
			    tileMapData, 
			    tileMapCount);
		    *dst++ = (tile >> 8) & 0xff; // High byte.
		    *dst++ = tile & 0xff; // Low byte.
		}
	    }
	    break;
	}

	case TILE_CODE_COMPRESSED_TEXT: {
	    bufSize = tileSize * rows * cols * 3; // to be safe
	    buf = (char *)malloc(bufSize);
	    unsigned char *dst = (unsigned char *)buf;
	    int tileIndex = 0;
	    int tileIndexMax = rows * cols;
	    int offset = 0;
	    int skip = 0;

	    while ((tileIndex < tileIndexMax) &&
		   (offset < bufSize)) {
		int c = tileIndex % cols;
		int r = tileIndex / cols;
		int tileCacheOffset = 
		    (col + c) + ((row + r) * width);
//		printf("tileIndex %d tileCacheOffset %d tileViewCacheCount %d c %d r %d cols %d rows %d ",
//		    tileIndex,
//		    tileCacheOffset,
//		    tileViewCacheCount,
//		    c, r, cols, rows);
		int tile = 
		    getValue(
			col + c, 
			row + r, 
			tileFunction,
			tileMapData, 
			tileMapCount);
//		printf("tile %d\n", tile);
		int curTile =
		    (tileViewCacheData == NULL)
			? -1
			: tileViewCacheData[tileCacheOffset];

		if (tile == curTile) {
		    skip++;
		} else {
//		    printf("tile %d skip %d offset %d r %d c %d index %d\n", tile, skip, offset, r, c, c + (r * width));
		    if (skip) {
			if (skip == 1) {
//			    printf("skip 1\n");
			    *dst++ = TILE_CODE_COMPRESSED_TEXT_SKIP_0;
			    offset++;
			} else if (skip == 2) {
//			    printf("skip 2/1\n");
			    *dst++ = TILE_CODE_COMPRESSED_TEXT_SKIP_0;
			    *dst++ = TILE_CODE_COMPRESSED_TEXT_SKIP_0;
			    offset += 2;
			} else if (skip < 64) {
//			    printf("skip %d/64\n", skip);
			    int val = skip;
			    *dst++ = TILE_CODE_COMPRESSED_TEXT_SKIP_1;
			    *dst++ = textCodeString[val];
			    offset += 2;
			} else if (skip < 4096) {
//			    printf("skip %d/4096\n", skip);
			    int val = skip;
			    *dst++ = TILE_CODE_COMPRESSED_TEXT_SKIP_2;
			    *dst++ = textCodeString[(val >> 6) & 63]; // High.
			    *dst++ = textCodeString[val & 63]; // Low.
			    offset += 3;
			} else {
//			    printf("skip %d/999999\n", skip);
			    int val = skip;
			    *dst++ = TILE_CODE_COMPRESSED_TEXT_SKIP_3;
			    *dst++ = textCodeString[(val >> 12) & 63]; // Highest.
			    *dst++ = textCodeString[(val >> 6) & 63]; // High.
			    *dst++ = textCodeString[val & 63]; // Low.
			    offset += 4;
			}

			skip = 0;

		    }

		    if (tileViewCacheData != NULL) {
			tileViewCacheData[tileCacheOffset] = tile;
		    }

		    int low = tile & 63;
		    int high = (tile >> 6) & 63;
		    *dst++ = textCodeString[low];
		    *dst++ = textCodeString[high];

		    offset += 2;
		}

		tileIndex++;
	    }

	    bufSize = offset;

	    break;
	}
Beispiel #6
0
int
set_str_list(
    const char* propname,
    PyObject* value,
    Py_ssize_t len,
    Py_ssize_t maxlen,
    char (*dest)[72]) {

  PyObject*  str      = NULL;
  Py_ssize_t input_len;
  Py_ssize_t i        = 0;

  if (check_delete(propname, value)) {
    return -1;
  }

  if (maxlen == 0) {
    maxlen = 68;
  }

  if (!PySequence_Check(value)) {
    PyErr_Format(
        PyExc_TypeError,
        "'%s' must be a sequence of strings",
        propname);
    return -1;
  }

  if (PySequence_Size(value) != len) {
    PyErr_Format(
        PyExc_ValueError,
        "len(%s) must be %u",
        propname,
        (unsigned int)len);
    return -1;
  }

  /* We go through the list twice, once to verify that the list is
     in the correct format, and then again to do the data copy.  This
     way, we won't partially copy the contents and then throw an
     exception. */
  for (i = 0; i < len; ++i) {
    str = PySequence_GetItem(value, i);
    if (str == NULL) {
      return -1;
    }

    if (!(PyBytes_CheckExact(str) || PyUnicode_CheckExact(str))) {
      PyErr_Format(
          PyExc_TypeError,
          "'%s' must be a sequence of bytes or strings",
          propname);
      Py_DECREF(str);
      return -1;
    }

    input_len = PySequence_Size(str);
    if (input_len > maxlen) {
      PyErr_Format(
          PyExc_TypeError,
          "Each entry in '%s' must be less than %u characters",
          propname, (unsigned int)maxlen);
      Py_DECREF(str);
      return -1;
    } else if (input_len == -1) {
      Py_DECREF(str);
      return -1;
    }

    Py_DECREF(str);
  }

  for (i = 0; i < len; ++i) {
    str = PySequence_GetItem(value, i);
    if (str == NULL) {
      /* Theoretically, something has gone really wrong here, since
         we've already verified the list. */
      PyErr_Clear();
      PyErr_Format(
          PyExc_RuntimeError,
          "Input values have changed underneath us.  Something is seriously wrong.");
      return -1;
    }

    if (set_string(propname, str, dest[i], maxlen)) {
      PyErr_Clear();
      PyErr_Format(
          PyExc_RuntimeError,
          "Input values have changed underneath us.  Something is seriously wrong.");
      Py_DECREF(str);
      return -1;
    }

    Py_DECREF(str);
  }

  return 0;
}
Beispiel #7
0
/**
 * Parses calibration data.  The calibration data should be in the form of a
 * sequence of sequences. eg:
 *    [
 *        [ xs, ys, zs, xi, yi ], ...
 *    ]
 * where (xs, ys, zs) are the coordinates of a point in 3D space, and (xi, yi)
 * are the coordinates of the corresponding point in an image.
 *
 * If the method fails, it returns NULL and raises an appropriate exception.  
 * On success, a flat array of doubles will be PyMem_Malloc()'d and filled 
 * with the calibration data:
 *    { xs1, ys1, zs1, xi1, yi1, xs2, ys2, zs2, xi2, yi2, ... }
 * size will be populated with the number of calibration points.
 */
static double* parse_calibration_data(PyObject *pyobj, int *size)
{
        PyObject *subseq = NULL, *sstuple = NULL;
        int i = 0, ncoords = 0, index = 0;
        double *array = NULL, xs, ys, zs, xi, yi;

        /* check that pyobj is a sequence, and find out its size */
        if (PySequence_Check(pyobj) == 0)
        {
                PyErr_SetString(PyExc_TypeError, 
                        "First argument must be a sequence of coordinate " \
                        "sequences.");
                return NULL;
        }
        ncoords = PySequence_Size(pyobj);
        *size = ncoords;

        /* allocate memory */
        array = PyMem_Malloc(sizeof(double) * ncoords * 5);
        if (array == NULL)
                return NULL;

        /* iterate over each sub-sequence within pyobj, performing appropriate
         * checks and fetching data. */
        for (i = 0; i < ncoords; i++)
        {
                subseq = PySequence_GetItem(pyobj, i);
                if (PySequence_Check(subseq) == 0)
                {
                        Py_DECREF(subseq);
                        PyMem_Free(array);
                        PyErr_SetString(PyExc_TypeError,
                                "First argument must be a sequence of " \
                                "coordinate sequences.");
                        return NULL;
                }
                sstuple = PySequence_Tuple(subseq);
                Py_DECREF(subseq);
                if (sstuple == NULL)
                {
                        Py_DECREF(sstuple);
                        PyMem_Free(array);
                        PyErr_SetString(PyExc_TypeError,
                                "First argument must be a sequence of " \
                                "coordinate sequences.");
                        return NULL;
                }
                
                if (!PyArg_ParseTuple(sstuple, "ddddd", &xs, &ys, &zs,
                        &xi, &yi))
                {
                        Py_DECREF(sstuple);
                        PyMem_Free(array);
                        PyErr_SetString(PyExc_TypeError,
                                "First argument's coordinate sequences must " \
                                "contain 5 elements each: [x,y,z,xi,yi]");
                        return NULL;
                }
                
                array[index++] = xs;
                array[index++] = ys;
                array[index++] = zs;
                array[index++] = xi;
                array[index++] = yi;

                /* printf("xs = %f, ys = %f, zs = %f, xi = %f, yi = %f\n",
                        xs, ys, zs, xi, yi); */

                Py_DECREF(sstuple);
        }

        return array;
}
Beispiel #8
0
static PyObject *icosahedron(PyObject *self, PyObject *args, PyObject *kwargs)
{
  int image_side = 0.;
  double radius = 0.;
  PyObject *rotation_obj = NULL;
  PyObject *rotation_sequence;

  static char *kwlist[] = {"array_side", "radius", "rotation", NULL};
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "id|O", kwlist, &image_side, &radius, &rotation_obj)) {
    return NULL;
  }

  if (image_side <= 0) {
    PyErr_SetString(PyExc_ValueError, "Image side must be > 0.");
    return NULL;
  }

  if (radius <= 0.) {
    PyErr_SetString(PyExc_ValueError, "Radius must be > 0.");
  }

  double rotm_11, rotm_12, rotm_13;
  double rotm_21, rotm_22, rotm_23;
  double rotm_31, rotm_32, rotm_33;
  int rotate;
  if (rotation_obj == NULL) {
    rotate = 0;
  } else {
    rotate = 1;
    rotation_sequence = PySequence_Fast(rotation_obj, "Expected a sequence");
    
    long length = PySequence_Size(rotation_sequence);
    if (length != 3 && length != 4) {
      PyErr_SetString(PyExc_ValueError, "Rotation must be of length 4 (quaternion)");
      return NULL;
    }

    PyObject *seq_1 = PySequence_Fast_GET_ITEM(rotation_sequence, 0);
    PyObject *seq_2 = PySequence_Fast_GET_ITEM(rotation_sequence, 1);
    PyObject *seq_3 = PySequence_Fast_GET_ITEM(rotation_sequence, 2);
    PyObject *seq_4 = PySequence_Fast_GET_ITEM(rotation_sequence, 3);
    double quat_1 = PyFloat_AsDouble(seq_1);
    double quat_2 = PyFloat_AsDouble(seq_2);
    double quat_3 = PyFloat_AsDouble(seq_3);
    double quat_4 = PyFloat_AsDouble(seq_4);
      
    double quaternion_norm = sqrt(pow(quat_1, 2) + pow(quat_2, 2) + pow(quat_3, 2) + pow(quat_4, 2));
    quat_1 /= quaternion_norm;
    quat_2 /= quaternion_norm;
    quat_3 /= quaternion_norm;
    quat_4 /= quaternion_norm;
    
    rotm_11 = quat_1*quat_1 + quat_2*quat_2 - quat_3*quat_3 - quat_4*quat_4;
    rotm_12 = 2.*quat_2*quat_3 - 2.*quat_1*quat_4;
    rotm_13 = 2.*quat_2*quat_4 + 2.*quat_1*quat_3;
      
    rotm_21 = 2.*quat_2*quat_3 + 2.*quat_1*quat_4;
    rotm_22 = quat_1*quat_1 - quat_2*quat_2 + quat_3*quat_3 - quat_4*quat_4;
    rotm_23 = 2.*quat_3*quat_4 - 2.*quat_1*quat_2;

    rotm_31 = 2.*quat_2*quat_4 - 2.*quat_1*quat_3;
    rotm_32 = 2.*quat_3*quat_4 + 2.*quat_1*quat_2;
    rotm_33 = quat_1*quat_1 - quat_2*quat_2 - quat_3*quat_3 + quat_4*quat_4;
  }

  int out_dim[] = {image_side, image_side, image_side};
  PyObject *out_array = (PyObject *)PyArray_FromDims(3, out_dim, NPY_FLOAT64);
  double *out = PyArray_DATA(out_array);

  //double edge_thickness = 1./image_side;
  double edge_thickness = 1.;
  double half_edge_thickness = edge_thickness/2.;
  const double phi = (1.+sqrt(5.))/2.; //golden ratio

  double corner1[] = {0., 1., phi};
  double corner2[] = {1., phi, 0.};
  double corner3[] = {phi, 0., 1.};

  double original_radius = sqrt(1. + pow(phi, 2));
  double size_scaling = radius/original_radius;

  corner1[0] *= size_scaling; corner1[1] *= size_scaling; corner1[2] *= size_scaling;
  corner2[0] *= size_scaling; corner2[1] *= size_scaling; corner2[2] *= size_scaling;
  corner3[0] *= size_scaling; corner3[1] *= size_scaling; corner3[2] *= size_scaling;
  
  double center_z = (corner1[0]+corner2[0]+corner3[0])/3.;
  double center_y = (corner1[1]+corner2[1]+corner3[1])/3.;
  double center_x = (corner1[2]+corner2[2]+corner3[2])/3.;

  double normal1_z = (corner1[0] + corner2[0])/2. - center_z;
  double normal1_y = (corner1[1] + corner2[1])/2. - center_y;
  double normal1_x = (corner1[2] + corner2[2])/2. - center_x;

  double normal2_z = (corner2[0] + corner3[0])/2. - center_z;
  double normal2_y = (corner2[1] + corner3[1])/2. - center_y;
  double normal2_x = (corner2[2] + corner3[2])/2. - center_x;

  double normal3_z = (corner3[0] + corner1[0])/2. - center_z;
  double normal3_y = (corner3[1] + corner1[1])/2. - center_y;
  double normal3_x = (corner3[2] + corner1[2])/2. - center_x;

  double edge_distance = sqrt(pow(normal1_z, 2) + pow(normal1_y, 2) + pow(normal1_x, 2));
  normal1_z /= edge_distance; normal1_y /= edge_distance; normal1_x /= edge_distance;
  normal2_z /= edge_distance; normal2_y /= edge_distance; normal2_x /= edge_distance;
  normal3_z /= edge_distance; normal3_y /= edge_distance; normal3_x /= edge_distance;

  double face_normal_3[] = {phi/3., 0., (2.*phi+1.)/3.};
  double face_normal_2[] = {(2.*phi+1.)/3., phi/3., 0.};
  double face_normal_1[] = {0., (2.*phi+1.)/3., phi/3.};
  double face_normal_center[] = {1., 1., 1.};

  double face_distance = sqrt(pow(center_z, 2) + pow(center_y, 2) + pow(center_x, 2))/size_scaling;
  face_normal_1[0] /= face_distance; face_normal_1[1] /= face_distance; face_normal_1[2] /= face_distance;
  face_normal_2[0] /= face_distance; face_normal_2[1] /= face_distance; face_normal_2[2] /= face_distance;
  face_normal_3[0] /= face_distance; face_normal_3[1] /= face_distance; face_normal_3[2] /= face_distance;
  face_normal_center[0] /= sqrt(3.); face_normal_center[1] /= sqrt(3.);
  face_normal_center[2] /= sqrt(3.);
  
  face_distance = sqrt(pow(center_z, 2) + pow(center_y, 2) + pow(center_x, 2));

  double no_rot_x, no_rot_y, no_rot_z;
  double x, y, z;
  double projected_x, projected_y, projected_z;
  double scalar_product, distance;
  double image_side_float = (double) image_side;
  int x_pixel, y_pixel, z_pixel, i;
  for (z_pixel = 0; z_pixel < image_side; z_pixel++) {
    //x = fabs(((double)x_pixel - image_side_float/2. + 0.5));
    no_rot_z = ((double)z_pixel - image_side_float/2. + 0.5);
    for (y_pixel = 0; y_pixel < image_side; y_pixel++) {
      //y = fabs(((double)y_pixel - image_side_float/2. + 0.5));
      no_rot_y = ((double)y_pixel - image_side_float/2. + 0.5);
      for (x_pixel = 0; x_pixel < image_side; x_pixel++) {
	//z = fabs(((double)z_pixel - image_side_float/2. + 0.5));
	no_rot_x = ((double)x_pixel - image_side_float/2. + 0.5);
	
	if (rotate == 1) {
	  //Transpose rotation matrix in comparison to Max' code since I don't rotate the icosahedron but the coordinate system.
	  z = fabs(no_rot_z*rotm_11 + no_rot_y*rotm_21 + no_rot_x*rotm_31);
	  y = fabs(no_rot_z*rotm_12 + no_rot_y*rotm_22 + no_rot_x*rotm_32);
	  x = fabs(no_rot_z*rotm_13 + no_rot_y*rotm_23 + no_rot_x*rotm_33);
	} else {
	  z = fabs(no_rot_z);
	  y = fabs(no_rot_y);
	  x = fabs(no_rot_x);
	}
	
	scalar_product = x*face_normal_center[2] + y*face_normal_center[1] + z*face_normal_center[0];
	projected_x = x * face_distance/scalar_product;
	projected_y = y * face_distance/scalar_product;
	projected_z = z * face_distance/scalar_product;

	i = z_pixel*image_side*image_side + y_pixel*image_side + x_pixel;
	if ((projected_x-center_x)*normal1_x + (projected_y-center_y)*normal1_y +
	    (projected_z-center_z)*normal1_z > edge_distance) {
	  distance = x*face_normal_1[2] + y*face_normal_1[1] + z*face_normal_1[0];

	  if (distance > face_distance + half_edge_thickness) {
	    out[i] = 0.;
	  } else if (distance < face_distance - half_edge_thickness) {
	    out[i] = 1.;
	  } else {
	    out[i] = 0.5 + (face_distance - distance) / edge_thickness;
	  }
	    
	} else if ((projected_x-center_x)*normal2_x + (projected_y-center_y)*normal2_y +
		   (projected_z-center_z)*normal2_z > edge_distance) {
	  distance = x*face_normal_2[2] + y*face_normal_2[1] + z*face_normal_2[0];
	  if (distance > face_distance + half_edge_thickness) {
	    out[i] = 0.;
	  } else if (distance < face_distance - half_edge_thickness) {
	    out[i] = 1.;
	  } else {
	    out[i] = 0.5 + (face_distance - distance) / edge_thickness;
	  }

	} else if ((projected_x-center_x)*normal3_x + (projected_y-center_y)*normal3_y +
		   (projected_z-center_z)*normal3_z > edge_distance) {
	  distance = x*face_normal_3[2] + y*face_normal_3[1] + z*face_normal_3[0];
	  if (distance > face_distance + half_edge_thickness) {
	    out[i] = 0.;
	  } else if (distance < face_distance - half_edge_thickness) {
	    out[i] = 1.;
	  } else {
	    out[i] = 0.5 + (face_distance - distance) / edge_thickness;
	  }

	} else {
	  distance = x*face_normal_center[2] + y*face_normal_center[1] + z*face_normal_center[0];
	  if (distance > face_distance + half_edge_thickness) {
	    out[i] = 0.;
	  } else if (distance < face_distance - half_edge_thickness) {
	    out[i] = 1.;
	  } else {
	    out[i] = 0.5 + (face_distance - distance) / edge_thickness;
	  }
	}
      }
    }
  }
  return out_array;
}
Beispiel #9
0
static PyObject *
MARS_88_run(MARS_88 *self, PyObject *args, PyObject *kwds)
{
	PyObject *warriors;
	s32_t rounds = 1;
	s32_t seed = time(0); /* some "random" value */
	u32_t *result;
	PyObject *res;

	warrior_t *wlist;

	/* Get and check arguments. */
	static char *kwlist[] = {"warriors", "rounds", "seed", NULL};
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|ii", kwlist,
					 &warriors, &rounds, &seed)) {
		return NULL;
	}
	if (PySequence_Check(warriors) == 0) {
		PyErr_SetString(PyExc_ValueError, "List of warriors needed.");
		return NULL;
	}
	if (PySequence_Size(warriors) != 2) {
		PyErr_SetString(PyExc_ValueError,
				"Exactly two warriors are needed "\
				"to run a fight.");
		return NULL;
	}
	if (rounds < 1) {
		PyErr_SetString(PyExc_ValueError, "Invalid number of rounds.");
		return NULL;
	}
	if (seed < 0) {
		PyErr_SetString(PyExc_ValueError, "Invalid seed.");
		return NULL;
	}
	if (seed < self->mindistance) {
		PyErr_SetString(PyExc_ValueError, "Position of second "\
				"warrior cannot be smaller than minimal "\
				"warrior distance.");
		return NULL;
	}
	
	/* Try to convert warriors into internal format. */
	wlist = get_warriors88(warriors, 2, self->maxlength);
	if (wlist == NULL) {
		PyErr_SetString(PyExc_ValueError, "Couldn't load warriors.");
		return NULL;
	}

	/* Run all fights. */
	result = run_88(self->core, wlist, self->coresize, self->maxprocesses,
		        self->maxcycles, self->mindistance, rounds, seed);

	/* Build results. */
	res = Py_BuildValue("[[lll][lll]]", result[0], result[1], result[2],
			    result[1], result[0], result[2]);
	if (res == NULL) {
		free_warriors(wlist, 2);
		free(result);
		return NULL;
	}
	Py_INCREF(res);
		
	/* Clean up. */
	free_warriors(wlist, 2);
	free(result);
	
	return res;
}
Beispiel #10
0
int
set_pvcards(
    /*@propname@*/ const char* propname,
    PyObject* value,
    struct pvcard** pv,
    int *npv,
    int *npvmax) {

  PyObject*  subvalue  = NULL;
  int        i         = 0;
  Py_ssize_t size      = 0;
  int        ival      = 0;
  int        mval      = 0;
  double     dblvalue  = 0.0;
  void*      newmem    = NULL;

  if (!PySequence_Check(value)) {
    return -1;
  }
  size = PySequence_Size(value);
  if (size > 0x7fffffff) {
    return -1;
  }

  if (size > (Py_ssize_t)*npvmax) {
    newmem = malloc(sizeof(struct pvcard) * size);
    if (newmem == NULL) {
      PyErr_SetString(PyExc_MemoryError, "Could not allocate memory.");
      return -1;
    }
    free(*pv);
    *pv = newmem;
    *npvmax = (int)size;
  }

  /* Verify the entire list for correct types first, so we don't have
     to undo anything copied into the canonical array. */
  for (i = 0; i < size; ++i) {
    subvalue = PySequence_GetItem(value, i);
    if (subvalue == NULL) {
      return -1;
    }
    if (!PyArg_ParseTuple(subvalue, "iid", &ival, &mval, &dblvalue)) {
      Py_DECREF(subvalue);
      return -1;
    }
    Py_DECREF(subvalue);
  }

  for (i = 0; i < size; ++i) {
    subvalue = PySequence_GetItem(value, i);
    if (subvalue == NULL) {
      return -1;
    }
    if (!PyArg_ParseTuple(subvalue, "iid", &ival, &mval, &dblvalue)) {
      Py_DECREF(subvalue);
      return -1;
    }
    Py_DECREF(subvalue);

    (*pv)[i].i = ival;
    (*pv)[i].m = mval;
    (*pv)[i].value = dblvalue;
    (*npv) = i + 1;
  }

  return 0;
}
PyObject *
pycbc_Connection__stats(pycbc_Connection *self,
                        PyObject *args,
                        PyObject *kwargs)
{
    int rv;
    int ii;
    Py_ssize_t ncmds;
    lcb_error_t err;
    PyObject *keys = NULL;
    PyObject *ret = NULL;
    pycbc_MultiResult *mres = NULL;
    struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
    static char *kwlist[] = {  "keys", NULL };

    rv = PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &keys);

    if (!rv) {
        PYCBC_EXCTHROW_ARGS();
        return NULL;
    }

    if (keys == NULL || PyObject_IsTrue(keys) == 0) {
        keys = NULL;
        ncmds = 1;

    } else {
        if (!PySequence_Check(keys)) {
            PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "keys argument must be sequence");
            return NULL;
        }
        ncmds = PySequence_Size(keys);
    }

    rv = pycbc_common_vars_init(&cv, ncmds, sizeof(lcb_server_stats_cmd_t), 0);
    if (rv < 0) {
        return NULL;
    }

    if (keys) {
        for (ii =0; ii < ncmds; ii++) {
            char *key;
            Py_ssize_t nkey;
            PyObject *newkey = NULL;

            PyObject *curkey = PySequence_GetItem(keys, ii);
            lcb_server_stats_cmd_t *cmd = cv.cmds.stats + ii;
            rv = pycbc_BufFromString(curkey, &key, &nkey, &newkey);
            if (rv < 0) {
                PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ARGUMENTS,
                                   0,
                                   "bad key type in stats",
                                   curkey);
                goto GT_DONE;
            }

            cmd->v.v0.name = key;
            cmd->v.v0.nname = nkey;
            cv.cmdlist.stats[ii] = cmd;
            cv.enckeys[ii] = newkey;
        }

    } else {
        cv.cmdlist.stats[0] = cv.cmds.stats;
    }


    mres = (pycbc_MultiResult*)pycbc_multiresult_new(self);

    err = lcb_server_stats(self->instance, mres, ncmds, cv.cmdlist.stats);
    if (err != LCB_SUCCESS) {
        PYCBC_EXCTHROW_SCHED(err);
        goto GT_DONE;
    }

    err = pycbc_oputil_wait_common(self);

    if (err != LCB_SUCCESS) {
        PYCBC_EXCTHROW_WAIT(err);
        goto GT_DONE;
    }

    ret = (PyObject*)mres;

    GT_DONE:
    pycbc_common_vars_free(&cv);

    /* Force multi, it's always a MultiResult */
    pycbc_make_retval(PYCBC_ARGOPT_MULTI, &ret, &mres);
    Py_XDECREF(mres);
    return ret;
}
Beispiel #12
0
int
set_str_list(
    const char* propname,
    PyObject* value,
    Py_ssize_t len,
    Py_ssize_t maxlen,
    char (*dest)[72]) {

  PyObject*  str      = NULL;
  char*      str_char = NULL;
  Py_ssize_t str_len  = 0;
  Py_ssize_t i        = 0;

  if (check_delete(propname, value)) {
    return -1;
  }

  if (maxlen == 0) {
    maxlen = 68;
  }

  if (!PySequence_Check(value)) {
    PyErr_Format(
        PyExc_TypeError,
        "'%s' must be a sequence of strings",
        propname);
    return -1;
  }

  if (PySequence_Size(value) != len) {
    PyErr_Format(
        PyExc_ValueError,
        "len(%s) must be %u",
        propname,
        (unsigned int)len);
    return -1;
  }

  /* We go through the list twice, once to verify that the list is
     in the correct format, and then again to do the data copy.  This
     way, we won't partially copy the contents and then throw an
     exception. */
  for (i = 0; i < len; ++i) {
    str = PySequence_GetItem(value, i);
    if (str == NULL) {
      return -1;
    }

    #if PY3K
    if (!PyBytes_CheckExact(str)) {
    #else
    if (!PyString_CheckExact(str)) {
    #endif
      PyErr_Format(
          PyExc_TypeError,
          #if PY3K
          "'%s' must be a sequence of bytes",
          #else
          "'%s' must be a sequence of strings",
          #endif
          propname);
      Py_DECREF(str);
      return -1;
    }

    #if PY3K
    if (PyBytes_Size(str) > maxlen) {
    #else
    if (PyString_Size(str) > maxlen) {
    #endif
      PyErr_Format(
          PyExc_TypeError,
          #if PY3K
          "Each bytes in '%s' must be less than %u characters",
          #else
          "Each string in '%s' must be less than %u characters",
          #endif
          propname, (unsigned int)maxlen);
      Py_DECREF(str);
      return -1;
    }

    Py_DECREF(str);
  }

  for (i = 0; i < len; ++i) {
    str = PySequence_GetItem(value, i);
    if (str == NULL) {
      /* Theoretically, something has gone really wrong here, since
         we've already verified the list. */
      PyErr_Format(
          PyExc_RuntimeError,
          "Input values have changed underneath us.  Something is seriously wrong.");
      return -1;
    }

    /* We already know its a string of the correct length */
    #if PY3K
    if (PyBytes_AsStringAndSize(str, &str_char, &str_len)) {
    #else
    if (PyString_AsStringAndSize(str, &str_char, &str_len)) {
    #endif
      /* Theoretically, something has gone really wrong here, since
         we've already verified the list. */
      PyErr_Format(
          PyExc_RuntimeError,
          "Input values have changed underneath us.  Something is seriously wrong.");
      Py_DECREF(str);
      return -1;
    }

    strncpy(dest[i], str_char, (size_t)maxlen);

    Py_DECREF(str);
  }

  return 0;
}


/*@null@*/ PyObject*
get_pscards(
    /*@unused@*/ const char* propname,
    struct pscard* ps,
    int nps) {

  PyObject*  result    = NULL;
  PyObject*  subresult = NULL;
  Py_ssize_t i         = 0;

  if (nps < 0) {
    PyErr_SetString(PyExc_ValueError, "Object has no pscards");
    return NULL;
  }

  result = PyList_New((Py_ssize_t)nps);
  if (result == NULL) {
    return NULL;
  }

  for (i = 0; i < (Py_ssize_t)nps; ++i) {
    subresult = Py_BuildValue("iis", ps[i].i, ps[i].m, ps[i].value);
    if (subresult == NULL) {
      Py_DECREF(result);
      return NULL;
    }

    if (PyList_SetItem(result, i, subresult)) {
      Py_DECREF(subresult);
      Py_DECREF(result);
      return NULL;
    }
  }

  return result;
}

int
set_pscards(
    /*@unused@*/ const char* propname,
    PyObject* value,
    struct pscard** ps,
    int *nps,
    int *npsmax) {

  PyObject*   subvalue  = NULL;
  Py_ssize_t  i         = 0;
  Py_ssize_t  size      = 0;
  int         ival      = 0;
  int         mval      = 0;
  const char* strvalue  = 0;
  void*       newmem    = NULL;

  if (!PySequence_Check(value))
    return -1;
  size = PySequence_Size(value);
  if (size > 0x7fffffff) {
    /* Must be a 32-bit size */
    return -1;
  }

  if (size > (Py_ssize_t)*npsmax) {
    newmem = malloc(sizeof(struct pscard) * size);
    if (newmem == NULL) {
      PyErr_SetString(PyExc_MemoryError, "Could not allocate memory.");
      return -1;
    }
    free(*ps);
    *ps = newmem;
    *npsmax = (int)size;
  }

  /* Verify the entire list for correct types first, so we don't have
     to undo anything copied into the canonical array. */
  for (i = 0; i < size; ++i) {
    subvalue = PySequence_GetItem(value, i);
    if (subvalue == NULL) {
      return -1;
    }
    if (!PyArg_ParseTuple(subvalue, "iis", &ival, &mval, &strvalue)) {
      Py_DECREF(subvalue);
      return -1;
    }
    Py_DECREF(subvalue);
  }

  for (i = 0; i < size; ++i) {
    subvalue = PySequence_GetItem(value, i);
    if (subvalue == NULL) {
      return -1;
    }
    if (!PyArg_ParseTuple(subvalue, "iis", &ival, &mval, &strvalue)) {
      Py_DECREF(subvalue);
      return -1;
    }
    Py_DECREF(subvalue);

    (*ps)[i].i = ival;
    (*ps)[i].m = mval;
    strncpy((*ps)[i].value, strvalue, 72);
    (*ps)[i].value[71] = '\0';
    (*nps) = (int)(i + 1);
  }

  return 0;
}

/*@null@*/ PyObject*
get_pvcards(
    /*@unused@*/ const char* propname,
    struct pvcard* pv,
    int npv) {

  PyObject*  result    = NULL;
  PyObject*  subresult = NULL;
  Py_ssize_t i         = 0;

  if (npv < 0) {
    PyErr_SetString(PyExc_ValueError, "Object has no pvcards");
    return NULL;
  }

  result = PyList_New((Py_ssize_t)npv);
  if (result == NULL) {
    return NULL;
  }

  for (i = 0; i < (Py_ssize_t)npv; ++i) {
    subresult = Py_BuildValue("iid", pv[i].i, pv[i].m, pv[i].value);
    if (subresult == NULL) {
      Py_DECREF(result);
      return NULL;
    }

    if (PyList_SetItem(result, i, subresult)) {
      Py_DECREF(subresult);
      Py_DECREF(result);
      return NULL;
    }
  }

  return result;
}
static int convertTo_QList_0600QPair_0100QByteArray_0100QByteArray(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList<QPair<QByteArray,QByteArray> > **sipCppPtr = reinterpret_cast<QList<QPair<QByteArray,QByteArray> > **>(sipCppPtrV);

#line 286 "sip/QtCore/qpycore_qlist.sip"
    PyObject *iter = PyObject_GetIter(sipPy);

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

        return (iter
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(sipPy)
#endif
                && !PyUnicode_Check(sipPy));
    }

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QPair<QByteArray, QByteArray> > *ql = new QList<QPair<QByteArray, QByteArray> >;
 
    for (SIP_SSIZE_T i = 0; ; ++i)
    {
        PyErr_Clear();
        PyObject *seq = PyIter_Next(iter);

        if (!seq)
        {
            if (PyErr_Occurred())
            {
                delete ql;
                Py_DECREF(iter);
                *sipIsErr = 1;

                return 0;
            }

            break;
        }

        SIP_SSIZE_T sub_len;

        if (PySequence_Check(seq)
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(seq)
#endif
                && !PyUnicode_Check(seq))
            sub_len = PySequence_Size(seq);
        else
            sub_len = -1;

        if (sub_len != 2)
        {
            if (sub_len < 0)
                PyErr_Format(PyExc_TypeError,
                        "index " SIP_SSIZE_T_FORMAT " has type '%s' but a 2 element non-string sequence is expected",
                        i, Py_TYPE(seq)->tp_name);
            else
                PyErr_Format(PyExc_TypeError,
                        "index " SIP_SSIZE_T_FORMAT " is a sequence of " SIP_SSIZE_T_FORMAT " sub-elements but 2 sub-elements are expected",
                        i, sub_len);

            Py_DECREF(seq);
            delete ql;
            Py_DECREF(iter);
            *sipIsErr = 1;

            return 0;
        }

        PyObject *itm1 = PySequence_ITEM(seq, 0);

        if (!itm1)
        {
            Py_DECREF(seq);
            delete ql;
            Py_DECREF(iter);
            *sipIsErr = 1;

            return 0;
        }

        int state1;
        QByteArray *s1 = reinterpret_cast<QByteArray *>(
                sipForceConvertToType(itm1, sipType_QByteArray, sipTransferObj,
                        SIP_NOT_NONE, &state1, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "the first sub-element of index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QByteArray' is expected",
                    i, Py_TYPE(itm1)->tp_name);

            Py_DECREF(itm1);
            Py_DECREF(seq);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        PyObject *itm2 = PySequence_ITEM(seq, 1);

        if (!itm2)
        {
            sipReleaseType(s1, sipType_QByteArray, state1);
            Py_DECREF(itm1);
            Py_DECREF(seq);
            delete ql;
            Py_DECREF(iter);
            *sipIsErr = 1;

            return 0;
        }

        int state2;
        QByteArray *s2 = reinterpret_cast<QByteArray *>(
                sipForceConvertToType(itm2, sipType_QByteArray, sipTransferObj,
                        SIP_NOT_NONE, &state2, sipIsErr));
 
        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "the second sub-element of index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QByteArray' is expected",
                    i, Py_TYPE(itm2)->tp_name);

            Py_DECREF(itm2);
            sipReleaseType(s1, sipType_QByteArray, state1);
            Py_DECREF(itm1);
            Py_DECREF(seq);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        ql->append(QPair<QByteArray, QByteArray>(*s1, *s2));

        sipReleaseType(s2, sipType_QByteArray, state2);
        Py_DECREF(itm2);
        sipReleaseType(s1, sipType_QByteArray, state1);
        Py_DECREF(itm1);
        Py_DECREF(seq);
    }

    Py_DECREF(iter);
 
    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 224 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtNetwork/sipQtNetworkQList0600QPair0100QByteArray0100QByteArray.cpp"
}
/* Initializes the file objects IO pool
 * Returns 1 if successful or -1 on error
 */
int pyvslvm_file_objects_pool_initialize(
     libbfio_pool_t **pool,
     PyObject *sequence_object,
     int access_flags,
     libcerror_error_t **error )
{
	libbfio_handle_t *file_io_handle = NULL;
	PyObject *file_object            = NULL;
	static char *function            = "pyvslvm_file_objects_pool_initialize";
	Py_ssize_t sequence_size         = 0;
	int element_index                = 0;
	int file_io_pool_entry           = 0;
	int number_of_elements           = 0;

	if( pool == NULL )
	{
		libcerror_error_set(
		 error,
		 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
		 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
		 "%s: invalid pool.",
		 function );

		return( -1 );
	}
	if( *pool != NULL )
	{
		libcerror_error_set(
		 error,
		 LIBCERROR_ERROR_DOMAIN_RUNTIME,
		 LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
		 "%s: invalid pool value already set.",
		 function );

		return( -1 );
	}
	sequence_size = PySequence_Size(
	                 sequence_object );

	if( sequence_size > (Py_ssize_t) INT_MAX )
	{
		libcerror_error_set(
		 error,
		 LIBCERROR_ERROR_DOMAIN_RUNTIME,
		 LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
		 "%s: invalid sequence size value exceeds maximum.",
		 function );

		goto on_error;
	}
	number_of_elements = (int) sequence_size;

	if( libbfio_pool_initialize(
	     pool,
	     0,
	     LIBBFIO_POOL_UNLIMITED_NUMBER_OF_OPEN_HANDLES,
	     error ) != 1 )
	{
		libcerror_error_set(
		 error,
		 LIBCERROR_ERROR_DOMAIN_RUNTIME,
		 LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
		 "%s: unable to create pool.",
		 function );

		goto on_error;
	}
	for( element_index = 0;
	     element_index < number_of_elements;
	     element_index++ )
	{
		file_object = PySequence_GetItem(
		               sequence_object,
		               element_index );

		if( file_object == NULL )
		{
			libcerror_error_set(
			 error,
			 LIBCERROR_ERROR_DOMAIN_RUNTIME,
			 LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
			 "%s: missing file object IO handle.",
			 function );

			goto on_error;
		}
		if( pyvslvm_file_object_initialize(
		     &file_io_handle,
		     file_object,
		     error ) != 1 )
		{
			libcerror_error_set(
			 error,
			 LIBCERROR_ERROR_DOMAIN_RUNTIME,
			 LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
			 "%s: unable to create file IO handle.",
			 function );

			goto on_error;
		}
		if( libbfio_pool_append_handle(
		     *pool,
		     &file_io_pool_entry,
		     file_io_handle,
		     access_flags,
		     error ) != 1 )
		{
			libcerror_error_set(
			 error,
			 LIBCERROR_ERROR_DOMAIN_RUNTIME,
			 LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
			 "%s: unable to append file IO handle to pool.",
			 function );

			goto on_error;
		}
		file_io_handle = NULL;
	}
	return( 1 );

on_error:
	if( file_io_handle != NULL )
	{
		libbfio_handle_free(
		 &file_io_handle,
		 NULL );
	}
	if( *pool != NULL )
	{
		libbfio_pool_free(
		 pool,
		 NULL );
	}
	return( -1 );
}
PyObject *
pycbc_Bucket__stats(pycbc_Bucket *self, PyObject *args, PyObject *kwargs)
{
    int rv;
    int ii;
    Py_ssize_t ncmds;
    lcb_error_t err = LCB_ERROR;
    PyObject *keys = NULL, *is_keystats = NULL;
    struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
    static char *kwlist[] = {  "keys", "keystats", NULL };
    lcb_CMDSTATS cmd = { 0 };

    rv = PyArg_ParseTupleAndKeywords(args, kwargs, "|OO", kwlist,
        &keys, &is_keystats);

    if (!rv) {
        PYCBC_EXCTHROW_ARGS();
        return NULL;
    }

    if (keys == NULL || PyObject_IsTrue(keys) == 0) {
        keys = NULL;
        ncmds = 1;

    } else {
        if (!PySequence_Check(keys)) {
            PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "keys argument must be sequence");
            return NULL;
        }
        ncmds = PySequence_Size(keys);
    }

    rv = pycbc_common_vars_init(&cv, self, PYCBC_ARGOPT_MULTI, ncmds, 0);
    if (rv < 0) {
        return NULL;
    }

    if (keys) {
        for (ii =0; ii < ncmds; ii++) {
            char *key;
            Py_ssize_t nkey;
            PyObject *newkey = NULL;

            PyObject *curkey = PySequence_GetItem(keys, ii);
            rv = pycbc_BufFromString(curkey, &key, &nkey, &newkey);
            if (rv < 0) {
                PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ARGUMENTS, 0, "bad key type in stats", curkey);
                goto GT_DONE;
            }

            LCB_CMD_SET_KEY(&cmd, key, nkey);
            if (is_keystats && PyObject_IsTrue(is_keystats)) {
                cmd.cmdflags |= LCB_CMDSTATS_F_KV;
            }
            err = lcb_stats3(self->instance, cv.mres, &cmd);
            Py_XDECREF(newkey);
        }

    } else {
        err = lcb_stats3(self->instance, cv.mres, &cmd);
    }

    if (err != LCB_SUCCESS) {
        PYCBC_EXCTHROW_SCHED(err);
        goto GT_DONE;
    }

    if (-1 == pycbc_common_vars_wait(&cv, self)) {
        goto GT_DONE;
    }

    GT_DONE:
    pycbc_common_vars_finalize(&cv, self);
    return cv.ret;
}
Beispiel #16
0
static PyObject *
MARS_88_mw_run(MARS_88 *self, PyObject *args, PyObject *kwds)
{
	PyObject *warriors;
	s32_t rounds = 1;
	s32_t seed = time(0); /* some "random" value */
	u32_t *result;
	PyObject *res;
	u32_t numwarriors;
	warrior_t *wlist;

	PyObject *tmp;
	PyObject *value;
	u32_t i;
	u32_t j;

	/* Get and check arguments. */
	static char *kwlist[] = {"warriors", "rounds", "seed", NULL};
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|ii", kwlist,
					 &warriors, &rounds, &seed)) {
		return NULL;
	}
	if (PySequence_Check(warriors) == 0) {
		PyErr_SetString(PyExc_ValueError, "List of warriors needed.");
		return NULL;
	}
	numwarriors = PySequence_Size(warriors);
	if (numwarriors < 2) {
		PyErr_SetString(PyExc_ValueError,
				"At least two warriors are needed "\
				"to run a multiwarrior fight.");
		return NULL;
	}
	if (self->coresize < numwarriors * self->mindistance) {
		PyErr_SetString(PyExc_ValueError,
				"All warriors do not fit into the core.");
		return NULL;
	}
	if (rounds < 1) {
		PyErr_SetString(PyExc_ValueError, "Invalid number of rounds.");
		return NULL;
	}
	if (seed < 0) {
		PyErr_SetString(PyExc_ValueError, "Invalid seed.");
		return NULL;
	}
	if (seed < self->mindistance) {
		PyErr_SetString(PyExc_ValueError, "Position of second "\
				"warrior cannot be smaller than minimal "\
				"warrior distance.");
		return NULL;
	}
	
	/* Try to convert warriors into internal format. */
	wlist = get_warriors88(warriors, numwarriors, self->maxlength);
	if (wlist == NULL) {
		PyErr_SetString(PyExc_ValueError, "Couldn't load warriors.");
		return NULL;
	}

	/* Run all fights. */
	result = mw_run_88(self->core, numwarriors, wlist, self->coresize,
			   self->maxprocesses, self->maxcycles,
			   self->mindistance, rounds, seed);

	/* Partial cleanup. */
	free_warriors(wlist, numwarriors);
	
	/* Build results. */
	res = PyList_New(numwarriors);
	if (res == NULL) {
		free(result);
		return NULL;
	}
	for (i = 0; i < numwarriors; i++) {
		tmp = PyList_New(numwarriors + 1);
		if (tmp == NULL) {
			/* Free already generated items. */
			Py_DECREF(res);
			free(result);
			return NULL;
		}
		PyList_SetItem(res, i, tmp);
		for (j = 0; j < numwarriors + 1; j++) {
			value = py3long_or_py2int_from_long(result[i*(numwarriors+1)+j]);
			PyList_SetItem(tmp, j, value);
		}
	}
		
	/* Clean up. */
	free(result);
	
	return res;
}
CThunkObject *_ctypes_alloc_callback(PyObject *callable,
				    PyObject *converters,
				    PyObject *restype,
				    int flags)
{
	int result;
	CThunkObject *p;
	Py_ssize_t nArgs, i;
	ffi_abi cc;

	nArgs = PySequence_Size(converters);
	p = CThunkObject_new(nArgs);
	if (p == NULL)
		return NULL;

	assert(CThunk_CheckExact((PyObject *)p));

	p->pcl = _ctypes_alloc_closure();
	if (p->pcl == NULL) {
		PyErr_NoMemory();
		goto error;
	}

	p->flags = flags;
	for (i = 0; i < nArgs; ++i) {
		PyObject *cnv = PySequence_GetItem(converters, i);
		if (cnv == NULL)
			goto error;
		p->atypes[i] = _ctypes_get_ffi_type(cnv);
		Py_DECREF(cnv);
	}
	p->atypes[i] = NULL;

	Py_INCREF(restype);
	p->restype = restype;
	if (restype == Py_None) {
		p->setfunc = NULL;
		p->ffi_restype = &ffi_type_void;
	} else {
		StgDictObject *dict = PyType_stgdict(restype);
		if (dict == NULL || dict->setfunc == NULL) {
		  PyErr_SetString(PyExc_TypeError,
				  "invalid result type for callback function");
		  goto error;
		}
		p->setfunc = dict->setfunc;
		p->ffi_restype = &dict->ffi_type_pointer;
	}

	cc = FFI_DEFAULT_ABI;
#if defined(MS_WIN32) && !defined(_WIN32_WCE) && !defined(MS_WIN64)
	if ((flags & FUNCFLAG_CDECL) == 0)
		cc = FFI_STDCALL;
#endif
	result = ffi_prep_cif(&p->cif, cc,
			      Py_SAFE_DOWNCAST(nArgs, Py_ssize_t, int),
			      _ctypes_get_ffi_type(restype),
			      &p->atypes[0]);
	if (result != FFI_OK) {
		PyErr_Format(PyExc_RuntimeError,
			     "ffi_prep_cif failed with %d", result);
		goto error;
	}
	result = ffi_prep_closure(p->pcl, &p->cif, closure_fcn, p);
	if (result != FFI_OK) {
		PyErr_Format(PyExc_RuntimeError,
			     "ffi_prep_closure failed with %d", result);
		goto error;
	}

	Py_INCREF(converters);
	p->converters = converters;
	Py_INCREF(callable);
	p->callable = callable;
	return p;

  error:
	Py_XDECREF(p);
	return NULL;
}
Beispiel #18
0
/* Try to convert warrior into internal warrior format. Return 0 on success,
 * 1 on error. */
u32_t
get_warrior94(PyObject *w, warrior_t *warrior, u32_t maxlength)
{
	PyObject *tmp;
	s32_t length;
	s32_t start;
	
	/* Get length of warrior. */
	tmp = PyObject_GetAttrString(w, "length");
	if (tmp == NULL) {
		return 1;
	}
	if (!check_py3long_or_py2int(tmp)) {
		Py_DECREF(tmp);
		return 1;
	}
	length = py3long_or_py2int_as_long(tmp);
	Py_DECREF(tmp);
	if ((length < 1) | (length > maxlength)) {
		return 1;
	}

	/* Get start instruction. */
	tmp = PyObject_GetAttrString(w, "start");
	if (tmp == NULL) {
		return 1;
	}
	if (!check_py3long_or_py2int(tmp)) {
		Py_DECREF(tmp);
		return 1;
	}
	start = py3long_or_py2int_as_long(tmp);
	Py_DECREF(tmp);
	if ((start < 0) | (start >= length)) {
		return 1;
	}
	
	/* Check for instructions. */
	tmp = PyObject_GetAttrString(w, "instructions");
	if (tmp == NULL) {
		return 1;
	}
	if (!PySequence_Check(tmp)) {
		Py_DECREF(tmp);
		return 1;
	}
	if (PySequence_Size(tmp) != length) {
		Py_DECREF(tmp);
		return 1;
	}
	
	/* Get instructions. */
	warrior->insns = get_instructions94(tmp, length);
	Py_DECREF(tmp);
	if (warrior->insns == NULL) {
		return 1;
	}
	warrior->start = start;
	warrior->length = length;

	return 0;
}
Beispiel #19
0
int
set_pscards(
    /*@unused@*/ const char* propname,
    PyObject* value,
    struct pscard** ps,
    int *nps,
    int *npsmax) {

  PyObject*   subvalue  = NULL;
  Py_ssize_t  i         = 0;
  Py_ssize_t  size      = 0;
  int         ival      = 0;
  int         mval      = 0;
  const char* strvalue  = 0;
  void*       newmem    = NULL;

  if (!PySequence_Check(value))
    return -1;
  size = PySequence_Size(value);
  if (size > 0x7fffffff) {
    /* Must be a 32-bit size */
    return -1;
  }

  if (size > (Py_ssize_t)*npsmax) {
    newmem = malloc(sizeof(struct pscard) * size);
    if (newmem == NULL) {
      PyErr_SetString(PyExc_MemoryError, "Could not allocate memory.");
      return -1;
    }
    free(*ps);
    *ps = newmem;
    *npsmax = (int)size;
  }

  /* Verify the entire list for correct types first, so we don't have
     to undo anything copied into the canonical array. */
  for (i = 0; i < size; ++i) {
    subvalue = PySequence_GetItem(value, i);
    if (subvalue == NULL) {
      return -1;
    }
    if (!PyArg_ParseTuple(subvalue, "iis", &ival, &mval, &strvalue)) {
      Py_DECREF(subvalue);
      return -1;
    }
    Py_DECREF(subvalue);
  }

  for (i = 0; i < size; ++i) {
    subvalue = PySequence_GetItem(value, i);
    if (subvalue == NULL) {
      return -1;
    }
    if (!PyArg_ParseTuple(subvalue, "iis", &ival, &mval, &strvalue)) {
      Py_DECREF(subvalue);
      return -1;
    }
    Py_DECREF(subvalue);

    (*ps)[i].i = ival;
    (*ps)[i].m = mval;
    strncpy((*ps)[i].value, strvalue, 72);
    (*ps)[i].value[71] = '\0';
    (*nps) = (int)(i + 1);
  }

  return 0;
}
Beispiel #20
0
ffi_info *AllocFunctionCallback(PyObject *callable,
				PyObject *converters,
				PyObject *restype,
				int is_cdecl)
{
	int result;
	ffi_info *p;
	int nArgs, i;
	ffi_abi cc;

	nArgs = PySequence_Size(converters);
	p = (ffi_info *)PyMem_Malloc(sizeof(ffi_info) + sizeof(ffi_type) * (nArgs + 1));
	if (p == NULL) {
		PyErr_NoMemory();
		return NULL;
	}
	p->pcl = MallocClosure();
	if (p->pcl == NULL) {
		PyErr_NoMemory();
		goto error;
	}

	for (i = 0; i < nArgs; ++i) {
		PyObject *cnv = PySequence_GetItem(converters, i);
		if (cnv == NULL)
			goto error;
		p->atypes[i] = GetType(cnv);
		Py_DECREF(cnv);
	}
	p->atypes[i] = NULL;

	if (restype == Py_None) {
		p->setfunc = NULL;
		p->restype = &ffi_type_void;
	} else {
		StgDictObject *dict = PyType_stgdict(restype);
		if (dict == NULL || dict->setfunc == NULL) {
		  PyErr_SetString(PyExc_TypeError,
				  "invalid result type for callback function");
		  goto error;
		}
		p->setfunc = dict->setfunc;
		p->restype = &dict->ffi_type_pointer;
	}

	cc = FFI_DEFAULT_ABI;
#if defined(MS_WIN32) && !defined(_WIN32_WCE)
	if (is_cdecl == 0)
		cc = FFI_STDCALL;
#endif
	result = ffi_prep_cif(&p->cif, cc, nArgs,
			      GetType(restype),
			      &p->atypes[0]);
	if (result != FFI_OK) {
		PyErr_Format(PyExc_RuntimeError,
			     "ffi_prep_cif failed with %d", result);
		goto error;
	}
	result = ffi_prep_closure(p->pcl, &p->cif, closure_fcn, p);
	if (result != FFI_OK) {
		PyErr_Format(PyExc_RuntimeError,
			     "ffi_prep_closure failed with %d", result);
		goto error;
	}

	p->converters = converters;
	p->callable = callable;
	return p;

  error:
	if (p) {
		if (p->pcl)
			FreeClosure(p->pcl);
		PyMem_Free(p);
	}
	return NULL;
}
// Render fixed sized tiles, pre-drawn into the Cairo surface "tiles".
void TileEngine::renderTiles(
    cairo_t *ctx,
    cairo_surface_t *tilesSurf,
    int tilesWidth,
    int tilesHeight,
    PyObject *tileFunction,
    PyObject *tileMap,
    int tileSize,
    int renderCol,
    int renderRow,
    int renderCols,
    int renderRows,
    double alpha)
{

    if ((tileFunction != Py_None) &&
	!PyCallable_Check(tileFunction)) {
	PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileFunction to be a callable function or None");
	return;
    }

    // The tileMap should be an array of 4 byte integers,
    // mapping virtual tiles indices to absolute tile numbers.
    if ((tileMap != Py_None) &&
	!PySequence_Check(tileMap)) {
	PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileMap to be an array "
	    "of 4 byte integers or None");
	return;
    }

    const int *tileMapData = NULL;
    unsigned int tileMapCount = 0;

    if (tileMap != Py_None) {
	tileMapCount = (unsigned int)PySequence_Size(tileMap);
	Py_ssize_t tileMapLength = 0;
	if (PyObject_AsReadBuffer(
	    tileMap,
	    (const void **)&tileMapData,
	    &tileMapLength) != 0) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap with read buffer");
	    return;
	}

	int tileMapDataCount = 
	    (int)tileMapLength / sizeof(unsigned int);

	if (tileMapDataCount != (int)tileMapCount) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap read buffer of 4 byte integers");
	    return;
	}
    }

    int tilesPerRow = tilesWidth / tileSize;

    int renderX = renderCol * tileSize;
    int renderY = renderRow * tileSize;

    int r;
    for (r = 0; r < renderRows; r++) {
	int c;
	for (c = 0; c  < renderCols; c++) {
	    int col = (renderCol + c) % width;
	    int row = (renderRow + r) % height;

	    unsigned long tile =
		getValue(
		    col,
		    row,
		    tileFunction,
		    tileMapData,
		    tileMapCount);

	    double x = col * tileSize;
	    double y = row * tileSize;

	    // Tiles are arranged in a regular grid. 
	    // Calculate the position of the file in the 
	    // source tileSurf. 
	    int tileCol = tile % tilesPerRow;
	    int tileRow = tile / tilesPerRow;
	    int tileX = tileCol * tileSize;
	    int tileY = tileRow * tileSize;

	    // Draw a tile.

	    cairo_save(ctx);

	    cairo_translate(
		ctx,
		x - renderX,
		y - renderY);

	    cairo_rectangle(
		ctx,
		0,
		0,
		tileSize,
		tileSize);

	    cairo_clip(ctx);

	    cairo_set_source_surface(
		ctx,
		tilesSurf,
		-tileX,
		-tileY);

	    if (alpha >= 1.0) {
		cairo_paint(ctx);
	    } else {
		cairo_paint_with_alpha(ctx, alpha);
	    }

	    cairo_restore(ctx);

	}
    }
}
static PyObject *Py_convert_to_string(PyObject *self, PyObject *args, PyObject *kwds)
{
    py::PathIterator path;
    agg::trans_affine trans;
    agg::rect_d cliprect;
    PyObject *simplifyobj;
    bool simplify = false;
    SketchParams sketch;
    int precision;
    PyObject *codesobj;
    char *codes[5];
    bool postfix;
    char *buffer = NULL;
    size_t buffersize;
    PyObject *result;
    int status;

    if (!PyArg_ParseTuple(args,
                          "O&O&O&OO&iOO&:convert_to_string",
                          &convert_path,
                          &path,
                          &convert_trans_affine,
                          &trans,
                          &convert_rect,
                          &cliprect,
                          &simplifyobj,
                          &convert_sketch_params,
                          &sketch,
                          &precision,
                          &codesobj,
                          &convert_bool,
                          &postfix)) {
        return NULL;
    }

    if (simplifyobj == Py_None) {
        simplify = path.should_simplify();
    } else if (PyObject_IsTrue(simplifyobj)) {
        simplify = true;
    }

    if (!PySequence_Check(codesobj)) {
        return NULL;
    }
    if (PySequence_Size(codesobj) != 5) {
        PyErr_SetString(
            PyExc_ValueError,
            "codes must be a 5-length sequence of byte strings");
        return NULL;
    }
    for (int i = 0; i < 5; ++i) {
        PyObject *item = PySequence_GetItem(codesobj, i);
        if (item == NULL) {
            return NULL;
        }
        codes[i] = PyBytes_AsString(item);
        if (codes[i] == NULL) {
            return NULL;
        }
    }

    CALL_CPP("convert_to_string",
             (status = convert_to_string(
                 path, trans, cliprect, simplify, sketch,
                 precision, codes, postfix, &buffer,
                 &buffersize)));

    if (status) {
        free(buffer);
        if (status == 1) {
            PyErr_SetString(PyExc_MemoryError, "Memory error");
        } else if (status == 2) {
            PyErr_SetString(PyExc_ValueError, "Malformed path codes");
        }
        return NULL;
    }

    if (buffersize == 0) {
        result = PyBytes_FromString("");
    } else {
        result = PyBytes_FromStringAndSize(buffer, buffersize);
    }

    free(buffer);

    return result;
}
void TileEngine::renderPixels(
    cairo_surface_t *destSurf,
    cairo_surface_t *cmapSurf,
    PyObject *tileFunction,
    PyObject *tileMap,
    int renderCol,
    int renderRow,
    int renderCols,
    int renderRows)
{
    if ((tileFunction != Py_None) &&
	!PyCallable_Check(tileFunction)) {
	PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileFunction to be a callable function or None");
	return;
    }

    // The tileMap should be None, or an array of 4 byte integers,
    // mapping virtual tiles indices to absolute tile numbers.

    const int *tileMapData = NULL;
    unsigned int tileMapCount = 0;

    if (tileMap != Py_None) {

        if (!PySequence_Check(tileMap)) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap to be an array "
		"of 4 byte integers or None");
	    return;
	}

	tileMapCount = (unsigned int)PySequence_Size(tileMap);
	Py_ssize_t tileMapLength = 0;
	if (PyObject_AsReadBuffer(
	    tileMap,
	    (const void **)&tileMapData,
	    &tileMapLength) != 0) {
	    PyErr_SetString(
		PyExc_TypeError,
		"expected tileMap with read buffer");
	    return;
	}

	int tileMapDataCount = 
	    (int)tileMapLength / sizeof(unsigned int);

	if (tileMapDataCount != (int)tileMapCount) {
	  PyErr_SetString(
	    PyExc_TypeError,
	    "expected tileMap read buffer of 4 byte integers");
	  return;
	}
    }

    unsigned char *destData = cairo_image_surface_get_data(destSurf);
    int destStride = cairo_image_surface_get_stride(destSurf);

    unsigned char *cmapData = cairo_image_surface_get_data(cmapSurf);
    int cmapWidth = cairo_image_surface_get_width(cmapSurf);
    int cmapStride = cairo_image_surface_get_stride(cmapSurf);

    int r;
    for (r = 0; r < renderRows; r++) {
	int c;
	for (c = 0; c  < renderCols; c++) {
	    int col = (renderCol + c) % width;
	    int row = (renderRow + r) % height;

	    unsigned long tile = 
		getValue(
		    col,
		    row,
		    tileFunction,
		    tileMapData,
		    tileMapCount);

	    int sourceX = tile % cmapWidth;
	    int sourceY = tile / cmapWidth;

	    unsigned char *sourcePixel =
		cmapData +
		(sourceX * 4) +
		(sourceY * cmapStride);

	    unsigned char *destPixel =
		destData +
		(c * 4) +
		(r * destStride);

	    *(long *)destPixel = *(long *)sourcePixel;
	}
    }
}
Beispiel #24
0
static int
xpybList_init(xpybList *self, PyObject *args, PyObject *kw)
{
    static char *kwlist[] = { "parent", "offset", "length", "type", "size", NULL };
    Py_ssize_t i, datalen, cur, offset, length, size = -1;
    PyObject *parent, *type, *obj, *arglist;
    const char *data;

    if (!PyArg_ParseTupleAndKeywords(args, kw, "OnnO|n", kwlist, &parent,
				     &offset, &length, &type, &size))
	return -1;

    self->list = PyList_New(0);
    if (self->list == NULL)
	return -1;

    if (PyObject_AsReadBuffer(parent, (const void **)&data, &datalen) < 0)
	return -1;
    if (size > 0 && length * size + offset > datalen) {
	PyErr_Format(xpybExcept_base, "Protocol object buffer too short "
		     "(expected %zd got %zd).", length * size + offset, datalen);
	return -1;
    }

    cur = offset;

    for (i = 0; i < length; i++) {
	if (PyString_CheckExact(type)) {
	    obj = xpybList_build(type, length, data + cur);
	    if (obj == NULL)
		return -1;
	    cur += size;
	} else if (size > 0) {
	    arglist = Py_BuildValue("(Onn)", parent, cur, size);
	    obj = PyEval_CallObject(type, arglist);
	    Py_DECREF(arglist);
	    if (obj == NULL)
		return -1;
	    cur += size;
	} else {
	    arglist = Py_BuildValue("(On)", parent, cur);
	    obj = PyEval_CallObject(type, arglist);
	    Py_DECREF(arglist);
	    if (obj == NULL)
		return -1;
	    datalen = PySequence_Size(obj);
	    if (datalen < 0)
		return -1;
	    cur += datalen;
	}

	if (PyList_Append(self->list, obj) < 0)
	    return -1;
        Py_DECREF(obj);
    }

    self->buf = PyBuffer_FromObject(parent, offset, cur - offset);
    if (self->buf == NULL)
	return -1;

    return 0;
}
/**
 * Handle the proxy.response to con.
 * proxy.response
 *   .type can be either ERR, OK or RAW
 *   .resultset (in case of OK)
 *     .fields
 *     .rows
 *   .errmsg (in case of ERR)
 *   .packet (in case of nil)
 *  Note: if error occurred, should set the error string.
 */
int network_mysqld_con_python_handle_proxy_response(network_mysqld_con *con,
			PyObject *proxy){
	assert(proxy);

	PyObject *response = PyObject_GetAttrString(proxy, "response");
	//Note: the response is fetched through the tp_getset, and is a new reference.
	assert(response);
	Py_DECREF(response);

	PyObject *res_type = PyObject_GetAttrString(response, "type");
	if(!res_type){
		network_mysqld_con_send_error(con->client,
					C("Cannot get proxy.response.type"));
		return -1;
	}
	int res_type_int = PyInt_AsLong(res_type);
	Py_DECREF(res_type);

	switch(res_type_int){
	case MYSQLD_PACKET_OK:{
		PyObject *resultset = PyObject_GetAttrString(response, "resultset");
		if(!resultset){
			PyErr_Clear();
			guint64 affected_rows = 0;
			guint64 insert_id = 0;

			PyObject *ar = PyObject_GetAttrString(response, "affected_rows");
			if(!ar)
				PyErr_Clear();
			else if(PyLong_Check(ar))
				affected_rows = PyLong_AsLong(ar);
			else if(PyInt_Check(ar))
				affected_rows = PyInt_AsLong(ar);
			Py_XDECREF(ar);

			PyObject *ii = PyObject_GetAttrString(response, "insert_id");
			if(!ii)
				PyErr_Clear();
			else if(PyLong_Check(ii))
				insert_id = PyLong_AsLong(ii);
			else if(PyInt_Check(ii))
				insert_id = PyInt_AsLong(ii);
			Py_XDECREF(ii);

			network_mysqld_con_send_ok_full(con->client, affected_rows, insert_id, 0x0002, 0);
		}
		else{
			Py_DECREF(resultset);

			GPtrArray *fields = create_fields(resultset);
			if(!fields){
				network_mysqld_con_send_error(con->client,
							C("Cannot get proxy.response.resultset.fields!"));
				PyErr_Print();
				PyErr_Clear();
				return -1;
			}
			if(fields->len <= 0){
				network_mysqld_con_send_error(con->client,
							C("Size of proxy.response.resultset.fields is 0"));
				network_mysqld_proto_fielddefs_free(fields);
				return -1;
			}
			GPtrArray *rows = create_rows(resultset);
			if(!rows){
				network_mysqld_con_send_error(con->client,
							C("Cannot get proxy.response.resultset.rows"));
				PyErr_Print();
				network_mysqld_proto_fielddefs_free(fields);
				return -1;
			}

			network_mysqld_con_send_resultset(con->client, fields, rows);

			if (fields) {
				network_mysqld_proto_fielddefs_free(fields);
				fields = NULL;
			}

			if (rows) {
				guint i;
				for (i = 0; i < rows->len; i++) {
					GPtrArray *row = rows->pdata[i];
					guint j;
					for (j = 0; j < row->len; j++)
						if (row->pdata[j])
							g_free(row->pdata[j]);
					g_ptr_array_free(row, TRUE);
				}
				g_ptr_array_free(rows, TRUE);
				rows = NULL;
			}
		}
		break;}

	case MYSQLD_PACKET_ERR:{
		gint errcode = ER_UNKNOWN_ERROR;
		/** let's call ourself Dynamic SQL ... 07000 is "dynamic SQL error" */
		const gchar *sqlstate = "07000";
		gchar *errmsg = NULL;

		PyObject *err_code = PyObject_GetAttrString(response, "errcode");
		if(!err_code)
			//Here use the default error code: ER_UNKNOWN_ERROR
			PyErr_Clear();
		else{
			errcode = PyInt_AsLong(err_code);
			Py_DECREF(err_code);
		}

		PyObject *sql_state = PyObject_GetAttrString(response, "sqlstate");
		if(!sql_state)
			//Here use the default sql state: 07000
			PyErr_Clear();
		else{
			sqlstate = PyString_AsString(sql_state);
			Py_DECREF(sql_state);
		}

		PyObject *err_msg = PyObject_GetAttrString(response, "errmsg");
		if(!err_msg){
			PyErr_Clear();
			network_mysqld_con_send_error(con->client,
						C("(python) proxy.response.errmsg is nil"));
		}
		else{
			errmsg = PyString_AsString(err_msg);
			Py_DECREF(err_msg);
			network_mysqld_con_send_error_full(con->client, errmsg,
						strlen(errmsg), errcode, sqlstate);
		}

	    break;}

	case MYSQLD_PACKET_RAW:{
		PyObject *packets = PyObject_GetAttrString(response, "packets");
		if(!packets)
			goto queue_reset;

		int i;
		for(i = 0; i < PySequence_Size(packets); i++){
			PyObject *item = PySequence_GetItem(packets, i);
			//If invalid items doesn't influces valid ones before them.
			if(!item)
				goto queue_reset;
			if(!PyString_Check(item)){
				PyErr_SetString(PyExc_ValueError, "proxy.response.packets' "
							"items should be strings.");
				Py_DECREF(item);
				Py_DECREF(packets);
				goto queue_reset;
			}

			network_mysqld_queue_append(con->client, con->client->send_queue,
						PyString_AsString(item), PyString_Size(item));
			Py_DECREF(item);
		}
		Py_DECREF(packets);
queue_reset:
		/* reset the packet-id checks */
		network_mysqld_queue_reset(con->client);
		break;}
	default:
		g_critical("Now the response type is unknown: %d", res_type_int);
		return -1;
	}
	return 0;
}
Beispiel #26
0
static PyObject* pybullet_renderImage(PyObject* self, PyObject* args)
{
	if (0==sm)
	{
		PyErr_SetString(SpamError, "Not connected to physics server.");
		return NULL;
	}
	
	///request an image from a simulated camera, using a software renderer.
	struct b3CameraImageData imageData;
	PyObject* objViewMat,* objProjMat;
	int width,  height;
	
	if (PyArg_ParseTuple(args, "iiOO", &width, &height, &objViewMat, &objProjMat))
	{
	
		PyObject* seq;
		int i, len;
		PyObject* item;
		float viewMatrix[16];
		float projectionMatrix[16];
		int valid = 1;
		{
    		seq = PySequence_Fast(objViewMat, "expected a sequence");
    		len = PySequence_Size(objViewMat);
		//printf("objViewMat size = %d\n", len);
			if (len==16)
			{
				
				if (PyList_Check(seq))
				{
					for (i = 0; i < len; i++) 
					{
            			item = PyList_GET_ITEM(seq, i);
						viewMatrix[i] = PyFloat_AsDouble(item);
						float v = viewMatrix[i]; 
	 			//printf("view %d to %f\n", i,v);
	
					}
				}
				else
				{
					for (i = 0; i < len; i++)
					{
        			item = PyTuple_GET_ITEM(seq,i);
						viewMatrix[i] = PyFloat_AsDouble(item);
					}
				}
			} else
			{
				valid = 0;
			}
		}
		
		
		{
			seq = PySequence_Fast(objProjMat, "expected a sequence");
			len = PySequence_Size(objProjMat);
	//printf("projMat len = %d\n", len);
			if (len==16)
			{
				if (PyList_Check(seq))
				{
					for (i = 0; i < len; i++)
					{
							item = PyList_GET_ITEM(seq, i);
							projectionMatrix[i] = PyFloat_AsDouble(item);
					}
				}
				else
				{
					for (i = 0; i < len; i++)
					{
							item = PyTuple_GET_ITEM(seq,i);
							projectionMatrix[i] = PyFloat_AsDouble(item);
					}
				}
			} else
			{
					valid = 0;
			}
		}

    		Py_DECREF(seq);	
		{
			b3SharedMemoryCommandHandle command;
			
			command = b3InitRequestCameraImage(sm);
			if (valid)
			{
			//printf("set b3RequestCameraImageSetCameraMatrices\n");
			b3RequestCameraImageSetCameraMatrices(command, viewMatrix, projectionMatrix);
			}

			b3RequestCameraImageSetPixelResolution(command,width,height);
		
			if (b3CanSubmitCommand(sm))
			{
				b3SharedMemoryStatusHandle statusHandle;
				int statusType;
				statusHandle = b3SubmitClientCommandAndWaitStatus(sm, command);
				statusType = b3GetStatusType(statusHandle);
				if (statusType==CMD_CAMERA_IMAGE_COMPLETED)
				{
					PyObject *item2;
					PyObject* pyResultList;//store 4 elements in this result: width, height, rgbData, depth

					b3GetCameraImageData(sm, &imageData);
					//todo: error handling if image size is 0
					pyResultList =  PyTuple_New(4);
					PyTuple_SetItem(pyResultList, 0, PyInt_FromLong(imageData.m_pixelWidth));
					PyTuple_SetItem(pyResultList, 1, PyInt_FromLong(imageData.m_pixelHeight));	
			
					PyObject *pylistPos;
					PyObject* pylistDep;
					int i,j,p;

						//printf("image width = %d, height = %d\n", imageData.m_pixelWidth, imageData.m_pixelHeight);
						{

							PyObject *item;
						int bytesPerPixel = 4;//Red, Green, Blue, each 8 bit values
							int num=bytesPerPixel*imageData.m_pixelWidth*imageData.m_pixelHeight;
							pylistPos = PyTuple_New(num);
						pylistDep = PyTuple_New(imageData.m_pixelWidth*imageData.m_pixelHeight);
			
						for (i=0;i<imageData.m_pixelWidth;i++)
						{
							for (j=0;j<imageData.m_pixelHeight;j++)
							{
								int depIndex = i+j*imageData.m_pixelWidth;
								item = PyFloat_FromDouble(imageData.m_depthValues[depIndex]);
								PyTuple_SetItem(pylistDep, depIndex, item);
								for (p=0;p<bytesPerPixel;p++)
								{
									int pixelIndex = bytesPerPixel*(i+j*imageData.m_pixelWidth)+p;
									item = PyInt_FromLong(imageData.m_rgbColorData[pixelIndex]);
											PyTuple_SetItem(pylistPos, pixelIndex, item);
								}
							}
						}	
					}

					PyTuple_SetItem(pyResultList, 2,pylistPos);
					PyTuple_SetItem(pyResultList, 3,pylistDep);
					return pyResultList;	
				}	
			}
			
		}

	}

	Py_INCREF(Py_None);
	return Py_None;
}
Beispiel #27
0
void PyLink::setCoM(PyObject *v)
{
    if (PySequence_Size(v) != 3) return;
    PyListToVector(v, c);
}
RowSet* ConvertPythonToRowset(PyObject *v)
{
	RowSet *pRow;
	Py_ssize_t row, col;
	int i, j;
	if (!PySequence_Check(v))
	{
		outputerrf( _("invalid Python return") );
		return NULL;
	}

	row = PySequence_Size(v);
	col = 0;
	if (row > 0)
	{
		PyObject *cols = PySequence_GetItem(v, 0);
		if (!PySequence_Check(cols))
		{
			outputerrf( _("invalid Python return") );
			return NULL;
		}
		else
			col = PySequence_Size(cols);
	}

	pRow = MallocRowset((size_t)row, (size_t)col);
	for (i = 0; i < (int)pRow->rows; i++)
	{
		PyObject *e = PySequence_GetItem(v, i);

		if (!e)
		{
			outputf(_("Error getting item %d\n"), i);
			continue;
		}

		if (PySequence_Check(e))
		{
			for (j = 0; j < (int)pRow->cols; j++)
			{
				char buf[1024];
				PyObject *e2 = PySequence_GetItem(e, j);
				
				if (!e2)
				{
					outputf(_("Error getting sub item (%d, %d)\n"), i, j);
					continue;
				}
				if (PyUnicode_Check(e2))
					strcpy(buf, PyString_AsString(PyUnicode_AsUTF8String(e2)));
				else if (PyString_Check(e2))
					strcpy(buf, PyString_AsString(e2));
				else if (PyInt_Check(e2) || PyLong_Check(e2)
					|| !StrCaseCmp(e2->ob_type->tp_name, "Decimal"))	/* Not sure how to check for decimal type directly */
					sprintf(buf, "%d", (int)PyInt_AsLong(e2));
				else if (PyFloat_Check(e2))
					sprintf(buf, "%.4f", PyFloat_AsDouble(e2));
				else if (e2 == Py_None)
					sprintf(buf, "[%s]", _("none"));
				else
					sprintf(buf, "[%s]", _("unknown type"));

				SetRowsetData(pRow, (size_t)i, (size_t)j, buf);

				Py_DECREF(e2);
			}
		}
		else
		{
			outputf(_("Item %d is not a list\n"), i);
		}

		Py_DECREF(e);
	}
	return pRow;
}
Beispiel #29
0
void PyLink::setInertia(PyObject *v)
{
    if (PySequence_Size(v) != 9) return;
    PyListToMatrix33(v, I);
}
Beispiel #30
0
	static void* convertible(PyObject* obj_ptr){ if(!PySequence_Check(obj_ptr) || (VT::RowsAtCompileTime!=Eigen::Dynamic && (PySequence_Size(obj_ptr)!=VT::RowsAtCompileTime))) return 0;
		// check that sequence items are convertible to scalars (should be done in other converters as well?!); otherwise Matrix3 is convertible to Vector3, but then we fail in *construct* very unclearly (TypeError: No registered converter was able to produce a C++ rvalue of type double from this Python object of type Vector3)
		size_t len=PySequence_Size(obj_ptr);
		for(size_t i=0; i<len; i++) if(!pySeqItemCheck<typename VT::Scalar>(obj_ptr,i)) return 0;
		return obj_ptr;
	}