def contiguous(cls, source, typeCode=None):
"""Get contiguous array from source
source -- numpy Python array (or compatible object)
for use as the data source. If this is not a contiguous
array of the given typeCode, a copy will be made,
otherwise will just be returned unchanged.
typeCode -- optional 1-character typeCode specifier for
the numpy.array function.
All gl*Pointer calls should use contiguous arrays, as non-
contiguous arrays will be re-copied on every rendering pass.
Although this doesn"t raise an error, it does tend to slow
down rendering.
"""
typeCode = GL_TYPE_TO_ARRAY_MAPPING[typeCode]
try:
contiguous = source.flags.contiguous
except AttributeError as err:
if typeCode:
return numpy.ascontiguousarray(source, typeCode)
else:
return numpy.ascontiguousarray(source)
else:
if contiguous and (typeCode is None
or typeCode == source.dtype.char):
return source
elif (contiguous and cls.ERROR_ON_COPY):
from OpenGL import error
raise error.CopyError(
"""Array of type %r passed, required array of type %r""",
source.dtype.char,
typeCode,
)
else:
# We have to do astype to avoid errors about unsafe conversions
# XXX Confirm that this will *always* create a new contiguous array
# XXX Guard against wacky conversion types like uint to float, where
# we really don"t want to have the C-level conversion occur.
# XXX ascontiguousarray is apparently now available in numpy!
if cls.ERROR_ON_COPY:
from OpenGL import error
raise error.CopyError(
"""Non-contiguous array passed""",
source,
)
if typeCode is None:
typeCode = source.dtype.char
return numpy.ascontiguousarray(source, typeCode)
def from_param(cls, value, typeCode=None):
# TODO: raise CopyError if the flag is set!
converted = _bytes.as_8_bit(value)
result = StringHandler.from_param(converted)
if converted is not value:
if ERROR_ON_COPY:
raise error.CopyError(
"""Unicode string passed, cannot copy with ERROR_ON_COPY set, please use 8-bit strings"""
)
result._temporary_array_ = converted
return result
def arrayByteCount(cls, value, typeCode=None):
"""Given a data-value, calculate number of bytes required to represent"""
try:
return value.nbytes
except AttributeError, err:
if cls.ERROR_ON_COPY:
raise error.CopyError(
"""Non-numpy array passed to numpy arrayByteCount: %s""",
type(value),
)
value = cls.asArray(value, typeCode)
return value.nbytes
def from_param( cls, instance, typeCode=None ):
try:
pointer = cls.dataPointer( instance )
except TypeError as err:
array = cls.asArray( instance, typeCode )
pp = cls.dataPointer( array )
pp._temporary_array_ = (array,)
return pp
else:
if typeCode and instance.dtype != GL_TYPE_TO_ARRAY_MAPPING[ typeCode ]:
raise error.CopyError(
"""Array of type %r passed, required array of type %r""",
instance.dtype.char, typeCode,
)
return c_void_p( pointer )
def raiseErrorOnCopy(self, value, *args, **named):
raise error.CopyError(
"""%s passed, cannot copy with ERROR_ON_COPY set, please use an array type which has native data-pointer support (e.g. numpy or ctypes arrays)"""
% (value.__class__.__name__, ))
try:
contiguous = source.flags.contiguous
except AttributeError, err:
if typeCode:
return numpy.ascontiguousarray(source, typeCode)
else:
return numpy.ascontiguousarray(source)
else:
if contiguous and (typeCode is None
or typeCode == source.dtype.char):
return source
elif (contiguous and cls.ERROR_ON_COPY):
from OpenGL import error
raise error.CopyError(
"""Array of type %r passed, required array of type %r""",
source.dtype.char,
typeCode,
)
else:
# We have to do astype to avoid errors about unsafe conversions
# XXX Confirm that this will *always* create a new contiguous array
# XXX Guard against wacky conversion types like uint to float, where
# we really don't want to have the C-level conversion occur.
# XXX ascontiguousarray is apparently now available in numpy!
if cls.ERROR_ON_COPY:
from OpenGL import error
raise error.CopyError(
"""Non-contiguous array passed""",
source,
)
if typeCode is None:
