def get_dc_joystick_parameters(self):
"""
Returns DC joystick parameters.
Returns
-------
out : tuple
(maximum velocity lo, maximum velocity hi, acceleration lo,
acceleration hi, direction sense)
direction sense:
- DC_JS_DIRSENSE_POS = 1
- DC_JS_DIRSENSE_NEG = 2
"""
maximum_velocity_lo = ctypes.c_float()
maximum_velocity_hi = ctypes.c_float()
acceleration_lo = ctypes.c_float()
acceleration_hi = ctypes.c_float()
direction_sense = ctypes.c_long()
err_code = _lib.MOT_GetDCJoystickParams(self._serial_number,
ctypes.byref(maximum_velocity_lo),
ctypes.byref(maximum_velocity_hi),
ctypes.byref(acceleration_lo),
ctypes.byref(acceleration_hi),
ctypes.byref(direction_sense))
if (err_code != 0):
raise Exception("Getting DC joystick parameters failed: %s" %
_get_error_text(err_code))
return (maximum_velocity_lo.value,
maximum_velocity_hi.value,
acceleration_lo.value,
acceleration_hi.value,
direction_sense.value
)
def load(cls, filename):
""" @brief Loads a png from a file as a 16-bit heightmap.
@param filename Name of target .png image
@returns A 16-bit, 1-channel image.
"""
# Get various png parameters so that we can allocate the
# correct amount of storage space for the new image
dx, dy, dz = ctypes.c_float(), ctypes.c_float(), ctypes.c_float()
ni, nj = ctypes.c_int(), ctypes.c_int()
libfab.load_png_stats(filename, ni, nj, dx, dy, dz)
# Create a python image data structure
img = cls(ni.value, nj.value, channels=1, depth=16)
# Add bounds to the image
if math.isnan(dx.value):
print 'Assuming 72 dpi for x resolution.'
img.xmin, img.xmax = 0, 72*img.width/25.4
else: img.xmin, img.xmax = 0, dx.value
if math.isnan(dy.value):
print 'Assuming 72 dpi for y resolution.'
img.ymin, img.ymax = 0, 72*img.height/25.4
else: img.ymin, img.ymax = 0, dy.value
if not math.isnan(dz.value): img.zmin, img.zmax = 0, dz.value
# Load the image data from the file
libfab.load_png(filename, img.pixels)
img.filename = filename
return img
def draw_tracked_explo(self, te):
read_game = self.env.read_game
frame = self.env.frame
head_pos = VECTOR(te.pos.x, te.pos.y, te.pos.z + 10)
feet = read_game.world_to_screen(te.pos)
head = read_game.world_to_screen(head_pos)
if feet and head:
# claymore friend tracking
if te.model_name == "WEAPON_CLAYMORE":
if not te.planter.enemy:
te.model_name = "WEAPON_CLAYMORE-friend"
size_y = feet.y - head.y
if size_y < 12: size_y = 12.0
sprite = self.env.sprites.get_sprite(te.model_name)
if sprite:
frame.sprite.Begin(0)
scaling = size_y / float(_EXPLO_SPRITE_SIZE)
sprite_center = D3DXVECTOR2(0, 0)
trans = D3DXVECTOR2(feet.x - _EXPLO_SPRITE_SIZE*scaling/2, feet.y - _EXPLO_SPRITE_SIZE*scaling)
matrix = D3DMATRIX()
d3dxdll.D3DXMatrixAffineTransformation2D(byref(matrix), #@UndefinedVariable
c_float(scaling), # scaling
byref(sprite_center), # rotation center
c_float(0), # angle
byref(trans) # translation
)
frame.sprite.SetTransform(matrix)
frame.sprite.Draw(sprite, None, None, None, COLOR_CLAYMORE_SPRITE)
frame.sprite.End()
self.draw_distance_ESP(te.pos, feet.x, feet.y, COLOR_CLAYMORE_DISTANCE)
else:
pass
def sgemm(transA, transB, alpha, A, A_offset, lda, B, B_offset, ldb, beta, C,
C_offset, ldc, m, n, k, _queue=None, wait_for=None):
if _queue is None:
_queue = queues[random.randint(0, len(queues) - 1)]
cblas_row_major = ct.c_int(0)
transA = ct.c_int(1 if transA else 0)
transB = ct.c_int(1 if transB else 0)
lda = ct.c_size_t(int(lda))
ldb = ct.c_size_t(int(ldb))
ldc = ct.c_size_t(int(ldc))
m = ct.c_size_t(int(m))
n = ct.c_size_t(int(n))
k = ct.c_size_t(int(k))
alpha = ct.c_float(alpha)
beta = ct.c_float(beta)
if wait_for is None:
num_wait = 0
else:
num_wait, wait_for = make_event_array(wait_for)
done_evt = cl.cl_event()
err = _clblaslib.clblasSgemm(cblas_row_major, transA, transB, m, n, k,
alpha, A.ocl_buf, ct.c_size_t(A_offset),
lda, B.ocl_buf, ct.c_size_t(B_offset), ldb,
beta, C.ocl_buf, ct.c_size_t(C_offset), ldc,
ct.c_size_t(1), ct.byref(_queue),
ct.c_size_t(num_wait), wait_for,
ct.byref(done_evt))
if err:
raise Exception("clBLAS sgemm returned error code {}".format(err))
return done_evt
def convOutp3D(images, hidSums, targets, conv_desc, scaleTargets=0, dbias=None):
_ConvNet.convOutp3DGemm(
images.p_mat, hidSums.p_mat, targets.p_mat,
images.p_shape4d, hidSums.p_shape4d, targets.p_shape4d,
conv_desc, ct.c_float(scaleTargets), ct.c_float(1))
if dbias is not None:
AddUpAllLocs3D(hidSums, dbias)
def _init_from_npy2d(self, mat, missing, nthread):
"""
Initialize data from a 2-D numpy matrix.
If ``mat`` does not have ``order='C'`` (aka row-major) or is not contiguous,
a temporary copy will be made.
If ``mat`` does not have ``dtype=numpy.float32``, a temporary copy will be made.
So there could be as many as two temporary data copies; be mindful of input layout
and type if memory use is a concern.
"""
if len(mat.shape) != 2:
raise ValueError('Input numpy.ndarray must be 2 dimensional')
# flatten the array by rows and ensure it is float32.
# we try to avoid data copies if possible (reshape returns a view when possible
# and we explicitly tell np.array to try and avoid copying)
data = np.array(mat.reshape(mat.size), copy=False, dtype=np.float32)
self.handle = ctypes.c_void_p()
missing = missing if missing is not None else np.nan
if nthread is None:
_check_call(_LIB.XGDMatrixCreateFromMat(
data.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
c_bst_ulong(mat.shape[0]),
c_bst_ulong(mat.shape[1]),
ctypes.c_float(missing),
ctypes.byref(self.handle)))
else:
_check_call(_LIB.XGDMatrixCreateFromMat_omp(
data.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
c_bst_ulong(mat.shape[0]),
c_bst_ulong(mat.shape[1]),
ctypes.c_float(missing),
ctypes.byref(self.handle),
nthread))
def mul(self, a, b, out, alpha=1.0, beta=0.0):
w = self._wrappers
# Ensure the matrices are compatible
if a.nrow != out.nrow or a.ncol != b.nrow or b.ncol != out.ncol:
raise ValueError('Incompatible matrices for out = a*b')
# CUBLAS expects inputs to be column-major (or Fortran order in
# numpy parlance). However as C = A*B => C^T = (A*B)^T
# = (B^T)*(A^T) with a little trickery we can multiply our
# row-major matrices directly.
m, n, k = b.ncol, a.nrow, a.ncol
A, B, C = b, a, out
# Do not transpose either A or B
opA = opB = w.CUBLAS_OP_N
# α and β factors for C = α*(A*op(B)) + β*C
if a.dtype == np.float64:
cublasgemm = w.cublasDgemm
alpha_ct, beta_ct = c_double(alpha), c_double(beta)
else:
cublasgemm = w.cublasSgemm
alpha_ct, beta_ct = c_float(alpha), c_float(beta)
class MulKernel(ComputeKernel):
def run(iself, queue):
w.cublasSetStream(self._handle, queue.cuda_stream_comp.handle)
cublasgemm(self._handle, opA, opB, m, n, k,
alpha_ct, A, A.leaddim, B, B.leaddim,
beta_ct, C, C.leaddim)
return MulKernel()
def getBoxFilter(self,
time, point_coords,
data_set = 'isotropic1024coarse',
make_modulo = False,
field = 'velocity',
filter_width = 7*2*np.pi / 1024):
if not self.connection_on:
print('you didn\'t connect to the database')
sys.exit()
if not (point_coords.shape[-1] == 3):
print ('wrong number of values for coordinates in getBoxFilter')
sys.exit()
return None
if not (point_coords.dtype == np.float32):
print 'point coordinates in getBoxFilter must be floats. stopping.'
sys.exit()
return None
npoints = point_coords.shape[0]
for i in range(1, len(point_coords.shape)-1):
npoints *= point_coords.shape[i]
if make_modulo:
pcoords = np.zeros(point_coords.shape, np.float64)
pcoords[:] = point_coords
np.mod(pcoords, 2*np.pi, point_coords)
result_array = point_coords.copy()
self.lib.getBoxFilter(self.authToken,
ctypes.c_char_p(data_set),
ctypes.c_char_p(field),
ctypes.c_float(time),
ctypes.c_float(filter_width),
ctypes.c_int(npoints),
point_coords.ctypes.data_as(ctypes.POINTER(ctypes.POINTER(ctypes.c_float))),
result_array.ctypes.data_as(ctypes.POINTER(ctypes.POINTER(ctypes.c_float))))
return result_array
def getBlineAlt(self,
time, nsteps, ds,
x0,
sinterp = 4,
tinterp = 0,
data_set = 'mhd1024'):
if not self.connection_on:
print('you didn\'t connect to the database')
sys.exit()
if not (x0.shape[1] == 3 and len(x0.shape) == 2):
print ('wrong shape of initial condition in getBlineAlt, ', x0.shape)
sys.exit()
return None
npoints = x0.shape[0]
result_array = np.empty((nsteps+1, npoints, 3), dtype=np.float32)
result_array[0] = x0
self.lib.getBline(
self.authToken,
ctypes.c_char_p(data_set),
ctypes.c_float(time),
ctypes.c_int(nsteps),
ctypes.c_float(ds),
ctypes.c_int(sinterp), ctypes.c_int(tinterp), ctypes.c_int(npoints),
result_array.ctypes.data_as(ctypes.POINTER(ctypes.POINTER(ctypes.c_float))))
return result_array
def ENgetcontrol(self, iCindex):
"""
retrieves parameters that define a simple control
Arguments:
* iCindex = control index (position of control statement
in the input file, starting from 1)
Returns: tuple( int, int, float, int, float )
* control type code (see toolkit.optControlTypes)
* index of controlled link
* control setting on link
* index of controlling node (0 for TIMER
or TIMEOFDAY control)
* control level (tank level, junction
pressure, or time (seconds)
"""
iCtype = ctypes.c_int()
iLindex = ctypes.c_int()
fSetting = ctypes.c_float()
iNindex = ctypes.c_int()
fLevel = ctypes.c_float()
self.errcode = self.ENlib.ENgetcontrol(iCindex, byref(iCtype),
byref(iLindex), byref(fSetting),
byref(iNindex), byref(fLevel))
self._error()
return (iCtype.value, iLindex.value, fSetting.vlaue, iNindex.value,
fLevel.value)
def getVelocityParameters(self):
minimumVelocity = c_float()
acceleration = c_float()
maximumVelocity = c_float()
self.aptdll.MOT_GetVelParams(self.SerialNum, pointer(minimumVelocity), pointer(acceleration), pointer(maximumVelocity))
velocityParameters = [minimumVelocity.value, acceleration.value, maximumVelocity.value]
return velocityParameters
def get_3d_attributes(self): """Retrieves the 3D attributes of a sample, stream, or MOD music channel with 3D functionality.""" answer = dict(mode=c_ulong(), min=c_float(), max=c_float(), iangle=c_ulong(), oangle=c_ulong(), outvol=c_float()) bass_call(BASS_ChannelGet3DAttributes, self.handle, pointer(answer['mode']), pointer(answer['min']), pointer(answer['max']), pointer(answer['iangle']), pointer(answer['oangle']), pointer(answer['outvol'])) for k in answer: answer[k] = answer[k].value() return answer
def add_sums(self, mat, axis, mult=1., beta=1.):
"""
Add a multiple of the sums of the matrix mat along the given dimension
to self. Self is scaled by beta before adding anything.
"""
m = _cudamat.get_leading_dimension(mat.p_mat)
n = _cudamat.get_nonleading_dimension(mat.p_mat)
if axis == 0:
# sum along leading dimension
check_ones_matrix(m)
left = CUDAMatrix.ones.slice(0, m)
left.set_trans(True)
right = mat
elif axis == 1:
# sum along non-leading dimension
left = mat
check_ones_matrix(n)
right = CUDAMatrix.ones.slice(0, n)
err_code = _cudamat.dot(left.p_mat, right.p_mat, self.p_mat,
ct.c_float(beta), ct.c_float(mult))
if err_code:
raise generate_exception(err_code)
return self
def cameralookat(camera_x, camera_y, camera_z, center_x, center_y, center_z, up_x, up_y, up_z):
"""
This function sets the view matrix by getting the position of the camera, the position of the center of focus and the direction which should point up. This function takes effect when the next image is created. Therefore if you want to take pictures of the same data from different perspectives, you can call and gr3.cameralookat(), gr3.getpixmap_(), gr3.cameralookat(), gr3.getpixmap_(), ... without calling gr3_clear() and gr3_drawmesh() again.
**Parameters:**
`camera_x` : The x-coordinate of the camera
`camera_y` : The y-coordinate of the camera
`camera_z` : The z-coordinate of the camera
`center_x` : The x-coordinate of the center of focus
`center_y` : The y-coordinate of the center of focus
`center_z` : The z-coordinate of the center of focus
`up_x` : The x-component of the up direction
`up_y` : The y-component of the up direction
`up_z` : The z-component of the up direction
.. note::
Source: http://www.opengl.org/sdk/docs/man/xhtml/gluLookAt.xml
(as of 10/24/2011, licensed under SGI Free Software Licence B)
"""
_gr3.gr3_cameralookat(c_float(camera_x), c_float(camera_y), c_float(camera_z), c_float(center_x), c_float(center_y), c_float(center_z), c_float(up_x), c_float(up_y), c_float(up_z))
def setcameraprojectionparameters(vertical_field_of_view, zNear, zFar):
"""
This function sets the projection parameters. This function takes effect when the next image is created.
**Parameters:**
`vertical_field_of_view` : This parameter is the vertical field of view in degrees. It must be greater than 0 and less than 180.
`zNear` : The distance to the near clipping plane.
`zFar` : The distance to the far clipping plane.
**Raises:**
`gr3.GR3_Error.GR3_ERROR_EXPORT`: Raises GR3_Exception
+-------------------------+-------------------------------------------------------+
| GR3_ERROR_NONE | on success |
+-------------------------+-------------------------------------------------------+
| GR3_ERROR_INVALID_VALUE | if one (or more) of the arguments is out of its range |
+-------------------------+-------------------------------------------------------+
.. note::
The ratio between zFar and zNear influences the precision of the depth buffer, the greater `$ \\\\frac{zFar}{zNear} $`, the more likely are errors. So you should try to keep both values as close to each other as possible while making sure everything you want to be visible, is visible.
"""
_gr3.gr3_setcameraprojectionparameters(c_float(vertical_field_of_view), c_float(zNear), c_float(zFar))
def forward_gpu(self, x):
n, c, h, w = x[0].shape
out_h = conv.get_conv_outsize(h, self.kh, self.sy, self.ph)
out_w = conv.get_conv_outsize(w, self.kw, self.sx, self.pw)
out_c = self.W.shape[0]
y = cuda.empty((n, out_c, out_h, out_w), dtype=self.dtype)
if cuda.cudnn_enabled and self.use_cudnn:
handle = cudnn.get_handle()
x_desc = cudnn.create_tensor_descriptor(x[0])
y_desc = cudnn.create_tensor_descriptor(y)
self.filter_desc = cudnn.create_filter_descriptor(self.W)
self.conv_desc = cudnn.create_convolution_descriptor(
(self.ph, self.pw), (self.sy, self.sx))
if self.b is not None:
self.bias_desc = cudnn.create_tensor_descriptor(
self.b[None, :, None, None])
algo = libcudnn.getConvolutionForwardAlgorithm(
handle, x_desc.value, self.filter_desc.value,
self.conv_desc.value, y_desc.value, _fwd_pref,
self.max_workspace_size)
workspace_size = libcudnn.getConvolutionForwardWorkspaceSize(
handle, x_desc.value, self.filter_desc.value,
self.conv_desc.value, y_desc.value, algo)
workspace = cuda.empty(
(max(workspace_size // 4, 1),), dtype=self.dtype)
one = ctypes.c_float(1)
zero = ctypes.c_float(0)
libcudnn.convolutionForward(
handle, one, x_desc.value, x[0].data.ptr,
self.filter_desc.value, self.W.data.ptr, self.conv_desc.value,
algo, workspace.data.ptr, workspace_size, zero, y_desc.value,
y.data.ptr)
# TODO(beam2d): Support unshared bias
if self.b is not None:
libcudnn.addTensor(
handle, libcudnn.CUDNN_ADD_SAME_C, one,
self.bias_desc.value, self.b.data.ptr, one, y_desc.value,
y.data.ptr)
else:
# Implementation using im2col
self.col = conv.im2col_gpu(
x[0], self.kh, self.kw, self.sy, self.sx, self.ph, self.pw)
# TODO(beam2d): Use streams
W_mat = self.W.reshape(out_c, c * self.kh * self.kw)
col_mats = self.col.reshape(
n, c * self.kh * self.kw, out_h * out_w)
y_mats = y.reshape(n, out_c, out_h * out_w)
for i in moves.range(n):
y_mats[i] = W_mat.dot(col_mats[i])
# TODO(beam2d): Support unshared bias
if self.b is not None:
y += self.b.reshape((1, out_c, 1, 1))
return y,
def drawimage(xmin, xmax, ymin, ymax, pixel_width, pixel_height, window):
global _gr3
err = _gr3.gr3_drawimage(c_float(xmin), c_float(xmax),
c_float(ymin), c_float(ymax),
c_int(pixel_width), c_int(pixel_height), c_int(window))
if err:
raise GR3_Exception(err)
def CvtLinearSetupConvert(self, nscan, readingsPos, nReadings, signal1, voltage1, signal2, voltage2, avg, scans):
"""Both sets up the linear conversion process and converts the ADC
readings into floating point numbers."""
counts = self.dataBuf
fValues = (ct.c_float * self.dBufSz)()
nValues = self.dBufSz
err = daq.daqCvtLinearSetupConvert(
wt.DWORD(nscan),
wt.DWORD(readingsPos),
wt.DWORD(nReadings),
ct.c_float(signal1),
ct.c_float(voltage1),
ct.c_float(signal2),
ct.c_float(voltage2),
wt.DWORD(avg),
ct.pointer(counts),
wt.DWORD(scans),
ct.pointer(fValues),
wt.DWORD(nValues),
)
if err != 0:
raise DaqError(err)
return fValues
def homeParams(self): direction = c_long() switch = c_long() velocity = c_float() zero_offset = c_float() self.ctrl.GetHomeParams(self.channel, byref(direction), byref(switch), byref(velocity), byref(zero_offset)) return direction.value, switch.value, velocity.value, zero_offset.value
def setVelocityParameters(self, serialNumber, minVel, acc, maxVel):
HWSerialNum = c_long(serialNumber)
minimumVelocity = c_float(minVel)
acceleration = c_float(acc)
maximumVelocity = c_float(maxVel)
self.aptdll.MOT_SetVelParams(HWSerialNum, minimumVelocity, acceleration, maximumVelocity)
return True
def CvtSetAdcRange(self, Admin, Admax):
"""Sets the ADC range for use by the conversion functions (i.e., all
functions of the form daqCvt... )."""
err = daq.daqCvtSetAdcRange(ct.c_float(Admin), ct.c_float(Admax))
if err != 0:
raise DaqError(err)
def sum(mat, axis, target = None):
"""
Sum the matrix along the given dimension, where 0 represents the leading
dimension and 1 represents the non-leading dimension. If a target is
not prvided, a new vector is created for storing the result.
"""
m = _cudamat.get_leading_dimension(mat.p_mat)
n = _cudamat.get_nonleading_dimension(mat.p_mat)
if axis == 0:
# sum along leading dimension
left = CUDAMatrix.ones.slice(0, m)
left.set_trans(True)
right = mat
if not target:
target = empty((1, n))
elif axis == 1:
# sum along non-leading dimension
left = mat
right = CUDAMatrix.ones.slice(0, n)
if not target:
target = empty((m, 1))
err_code = _cudamat.dot(left.p_mat, right.p_mat, target.p_mat, ct.c_float(0.), ct.c_float(1.))
if err_code:
raise generate_exception(err_code)
return target
def getTimeBaseIndices(self, name, tBegin, tEnd):
""" Return time indices of name corresponding to tBegin and tEnd """
if not self.status:
raise Exception('Shotfile not open!')
try:
sigName = ctypes.c_char_p(name)
except TypeError:
sigName = ctypes.c_char_p(name.encode())
error = ctypes.c_int32(0)
info = self.getTimeBaseInfo(name)
if tEnd < tBegin:
temp = tEnd
tEnd = tBegin
tBegin = temp
if tBegin < info.tBegin:
tBegin = info.tBegin
if tEnd > info.tEnd:
tEnd = info.tEnd
try:
time1 = ctypes.c_float(tBegin)
except TypeError:
time1 = ctypes.c_float(tBegin.value)
try:
time2 = ctypes.c_float(tEnd)
except TypeError:
time2 = ctypes.c_float(tEnd.value)
k1 = ctypes.c_uint32(0)
k2 = ctypes.c_uint32(0)
lname = ctypes.c_uint64(len(name))
__libddww__.ddtindex_(ctypes.byref(error), ctypes.byref(self.diaref), sigName, ctypes.byref(time1),
ctypes.byref(time2), ctypes.byref(k1), ctypes.byref(k2), lname)
getError(error.value)
return numpy.uint32(k1.value), numpy.uint32(k2.value)
def getMaxNumRef(sMax, volume, sMin=0.0, multip=2):
fn = lib.__cfml_reflections_utilities_MOD_get_maxnumref
fn.argtypes = [POINTER(c_float), POINTER(c_float), POINTER(c_float),
POINTER(c_int)]
fn.restype = c_int
numref = fn(c_float(sMax), c_float(volume), c_float(sMin), c_int(multip))
return numref
def _widget_value(self, pair):
(root, child) = pair
w_type = self._widget_type(pair)
if w_type == 'text' or w_type == 'menu' or w_type == 'radio':
ptr = ctypes.c_char_p()
res = gphoto.gp_widget_get_value(child, ctypes.pointer(ptr))
gphoto_check(res)
return (w_type, ptr.value)
elif w_type == 'range':
top = ctypes.c_float()
bottom = ctypes.c_float()
step = ctypes.c_float()
value = ctypes.c_float()
res = gphoto.gp_widget_get_range(child, ctypes.pointer(bottom), ctypes.pointer(top), ctypes.pointer(step))
gphoto_check(res)
res = gphoto.gp_widget_get_value(child, ctypes.pointer(value))
gphoto_check(res)
return (w_type, value.value, bottom.value, top.value, step.value)
elif w_type == 'toggle' or w_type == 'date':
value = ctypes.c_int()
res = gphoto.gp_widget_get_value(child, ctypes.pointer(value))
gphoto_check(res)
return (w_type, value.value)
else:
return None
def call_pipe(app_data):
rows = app_data['rows']
cols = app_data['cols']
app_args = app_data['app_args']
colour_temp = float(app_args.colour_temp)
contrast = float(app_args.contrast)
gamma = float(app_args.gamma)
img_data = app_data['img_data']
IN = img_data['IN']
M3200 = img_data['M3200']
M7000 = img_data['M7000']
OUT = img_data['OUT']
# lib function name
func_name = 'pipeline_'+app_data['app']
pipe_func = app_data[func_name]
# lib function args
pipe_args = []
pipe_args += [ctypes.c_int(cols)]
pipe_args += [ctypes.c_int(rows)]
pipe_args += [ctypes.c_float(colour_temp)]
pipe_args += [ctypes.c_float(contrast)]
pipe_args += [ctypes.c_float(gamma)]
pipe_args += [ctypes.c_void_p(IN.ctypes.data)]
pipe_args += [ctypes.c_void_p(M3200.ctypes.data)]
pipe_args += [ctypes.c_void_p(M7000.ctypes.data)]
pipe_args += [ctypes.c_void_p(OUT.ctypes.data)]
# call lib function
pipe_func(*pipe_args)
return
def rednoise(self,startwidth=6,endwidth=100,endfreq=1.0):
"""Perform rednoise removal via Presto style method.
:param startwidth: size of initial array for median calculation
:type startwidth: int
:param endwidth: size of largest array for median calculation
:type endwidth: int
:param endfreq: remove rednoise up to this frequency
:type endfreq: float
:return: whitened fourier series
:rtype: :class:`~sigpyproc.FourierSeries.FourierSeries`
"""
out_ar = np.empty_like(self)
buf_c1 = np.empty(2*endwidth,dtype="float32")
buf_c2 = np.empty(2*endwidth,dtype="float32")
buf_f1 = np.empty(endwidth,dtype="float32")
lib.rednoise(as_c(self),
as_c(out_ar),
as_c(buf_c1),
as_c(buf_c2),
as_c(buf_f1),
C.c_int(self.size/2),
C.c_float(self.header.tsamp),
C.c_int(startwidth),
C.c_int(endwidth),
C.c_float(endfreq))
return FourierSeries(out_ar,self.header.newHeader())
def detectionOutput_fprop(self, conf_view, loc_view, detection, prior_boxes,
proposals, nms_top_k, image_top_k, score_threshold, nms_threshold):
conf = c_longlong(conf_view._tensor.ctypes.data)
loc = c_longlong(loc_view._tensor.ctypes.data)
detection = c_longlong(detection._tensor.ctypes.data)
prior_boxes = c_longlong(prior_boxes._tensor.ctypes.data)
L, num_class, bs = conf_view.shape
proposals = c_longlong(proposals._tensor.ctypes.data)
result = np.zeros((bs, image_top_k, 6), dtype=np.float32)
result_ptr = c_longlong(result.ctypes.data)
result_len = np.zeros(bs, dtype=np.int64)
result_len_ptr = c_longlong(result_len.ctypes.data)
self.mklEngine.detection_fprop(conf, loc, result_ptr, prior_boxes,
result_len_ptr, c_longlong(L), c_longlong(num_class),
c_longlong(bs), c_longlong(nms_top_k),
c_longlong(image_top_k),
c_float(score_threshold),
c_float(nms_threshold))
batch_all_detections = [None] * self.bsz
for i in range(bs):
leng = np.long(result_len[i])
res_batch = np.zeros((leng, 6))
res_batch[:] = result[i, 0:leng, :]
batch_all_detections[i] = res_batch
return batch_all_detections
def sgemv(transA, M, N, alpha, bufA, offA, lda, bufX, offX, incx, beta, bufY,
offY, incy, wait_for=None):
cblas_row_major = ct.c_int(0)
transA = ct.c_int(1 if transA else 0)
lda = ct.c_size_t(int(lda))
incx = ct.c_size_t(int(incx))
incy = ct.c_size_t(int(incy))
M = ct.c_size_t(int(M))
N = ct.c_size_t(int(N))
alpha = ct.c_float(alpha)
beta = ct.c_float(beta)
if wait_for is None:
num_wait = 0
else:
num_wait = 1
wait_for = ct.byref(wait_for)
done_evt = cl.cl_event()
err = _clblaslib.clblasSgemv(cblas_row_major, transA, M, N,
alpha, bufA.ocl_buf, ct.c_size_t(offA), lda,
bufX.ocl_buf, ct.c_size_t(offX), incx, beta,
bufY.ocl_buf, ct.c_size_t(offY), incy,
ct.c_size_t(1), ct.byref(queues[0]),
ct.c_size_t(num_wait), wait_for,
ct.byref(done_evt))
if err:
raise Exception("clBLAS sgemv returned error code {}".format(err))
return done_evt
def getVelocityParameterLimits(self, serialNumber):
HWSerialNum = c_long(serialNumber)
maximumAcceleration = c_float()
maximumVelocity = c_float()
self.aptdll.MOT_GetVelParamLimits(HWSerialNum, pointer(maximumAcceleration), pointer(maximumVelocity))
velocityParameterLimits = [maximumAcceleration.value, maximumVelocity.value]
return velocityParameterLimits
def test_array_types(self):
# This test need to make sure that the Scala type selected is at least
# as large as the python's types. This is necessary because python's
# array types depend on C implementation on the machine. Therefore there
# is no machine independent correspondence between python's array types
# and Scala types.
# See: https://docs.python.org/2/library/array.html
def assert_collect_success(typecode, value, element_type):
self.assertEqual(
element_type,
str(_infer_type(array.array(typecode, [value])).element_type))
# supported string types
#
# String types in python's array are "u" for Py_UNICODE and "c" for char.
# "u" will be removed in python 4, and "c" is not supported in python 3.
supported_string_types = []
if sys.version_info[0] < 4:
supported_string_types += ['u']
# test unicode
assert_collect_success('u', u'a', 'CHAR')
if sys.version_info[0] < 3:
supported_string_types += ['c']
# test string
assert_collect_success('c', 'a', 'CHAR')
# supported float and double
#
# Test max, min, and precision for float and double, assuming IEEE 754
# floating-point format.
supported_fractional_types = ['f', 'd']
assert_collect_success('f', ctypes.c_float(1e+38).value, 'FLOAT')
assert_collect_success('f', ctypes.c_float(1e-38).value, 'FLOAT')
assert_collect_success('f', ctypes.c_float(1.123456).value, 'FLOAT')
assert_collect_success('d', sys.float_info.max, 'DOUBLE')
assert_collect_success('d', sys.float_info.min, 'DOUBLE')
assert_collect_success('d', sys.float_info.epsilon, 'DOUBLE')
def get_int_data_type(size):
if size <= 8:
return "TINYINT"
if size <= 16:
return "SMALLINT"
if size <= 32:
return "INT"
if size <= 64:
return "BIGINT"
# supported signed int types
#
# The size of C types changes with implementation, we need to make sure
# that there is no overflow error on the platform running this test.
supported_signed_int_types = list(
set(_array_signed_int_typecode_ctype_mappings.keys()).intersection(
set(_array_type_mappings.keys())))
for t in supported_signed_int_types:
ctype = _array_signed_int_typecode_ctype_mappings[t]
max_val = 2**(ctypes.sizeof(ctype) * 8 - 1)
assert_collect_success(t, max_val - 1,
get_int_data_type(ctypes.sizeof(ctype) * 8))
assert_collect_success(t, -max_val,
get_int_data_type(ctypes.sizeof(ctype) * 8))
# supported unsigned int types
#
# JVM does not have unsigned types. We need to be very careful to make
# sure that there is no overflow error.
supported_unsigned_int_types = list(
set(_array_unsigned_int_typecode_ctype_mappings.keys()).
intersection(set(_array_type_mappings.keys())))
for t in supported_unsigned_int_types:
ctype = _array_unsigned_int_typecode_ctype_mappings[t]
max_val = 2**(ctypes.sizeof(ctype) * 8 - 1)
assert_collect_success(
t, max_val, get_int_data_type(ctypes.sizeof(ctype) * 8 + 1))
# all supported types
#
# Make sure the types tested above:
# 1. are all supported types
# 2. cover all supported types
supported_types = (supported_string_types +
supported_fractional_types +
supported_signed_int_types +
supported_unsigned_int_types)
self.assertEqual(set(supported_types),
set(_array_type_mappings.keys()))
# all unsupported types
#
# Keys in _array_type_mappings is a complete list of all supported types,
# and types not in _array_type_mappings are considered unsupported.
# `array.typecodes` are not supported in python 2.
if sys.version_info[0] < 3:
all_types = {
'c', 'b', 'B', 'u', 'h', 'H', 'i', 'I', 'l', 'L', 'f', 'd'
}
else:
all_types = set(array.typecodes)
unsupported_types = all_types - set(supported_types)
# test unsupported types
for t in unsupported_types:
with self.assertRaises(TypeError):
_infer_schema_from_data([Row(myarray=array.array(t))])
def __call__( self: 'Circle', window: 'Window' ) -> None:
bdl.drawCircle( window.window, self.pos.to_c( ), ctypes.c_float( self.rad ), self.color.to_c( ), ctypes.c_int( self.outline ), self.outline_color.to_c( ) )
def setKineticCycleTime(self, kinetic_time):
setCurrentCamera(self.camera_handle)
self._abortIfAcquiring_()
andorCheck(andor.SetKineticCycleTime(ctypes.c_float(kinetic_time)), "SetKineticCycleTime")
self.kinetic_cycle_time = kinetic_time
def setExposureTime(self, exposure_time):
setCurrentCamera(self.camera_handle)
self._abortIfAcquiring_()
andorCheck(andor.SetExposureTime(ctypes.c_float(exposure_time)), "SetExposureTime")
self.exposure_time = exposure_time
def __init__(self, andor_path, camera_handle):
self.camera_handle = camera_handle
# General
self.pixels = 0
# Camera properties storage.
self._props_ = {}
# Initialize the camera.
setCurrentCamera(self.camera_handle)
andorCheck(andor.Initialize(andor_path + "Detector.ini"), "Initialize")
# Determine camera capabilities (useful??).
caps = AndorCapabilities(ctypes.sizeof(ctypes.c_ulong)*12,0,0,0,0,0,0,0,0,0,0,0)
andorCheck(andor.GetCapabilities(ctypes.byref(caps)), "GetCapabilities")
self._props_['AcqModes'] = caps.ulAcqModes
self._props_['ReadModes'] = caps.ulReadModes
self._props_['TriggerModes'] = caps.ulTriggerModes
self._props_['CameraType'] = caps.ulCameraType
self._props_['PixelMode'] = caps.ulPixelMode
self._props_['SetFunctions'] = caps.ulSetFunctions
self._props_['GetFunctions'] = caps.ulGetFunctions
self._props_['Features'] = caps.ulFeatures
self._props_['PCICard'] = caps.ulPCICard
self._props_['EMGainCapability'] = caps.ulEMGainCapability
self._props_['FTReadModes'] = caps.ulFTReadModes
# Determine camera bit depth.
# FIXME: Use andor.GetBitDepth()
for i in [[1, 2**8], [2, 2**14], [4, 2**16], [8, 2**32]]:
if (i[0] & self._props_['PixelMode']):
self._props_['MaxIntensity'] = i[1]
# Determine camera pixel size.
x_pixels = ctypes.c_long()
y_pixels = ctypes.c_long()
andorCheck(andor.GetDetector(ctypes.byref(x_pixels), ctypes.byref(y_pixels)), "GetDetector")
self._props_['XPixels'] = x_pixels.value
self._props_['YPixels'] = y_pixels.value
# Determine camera head model.
head_model = ctypes.create_string_buffer(32)
andorCheck(andor.GetHeadModel(head_model), "GetHeadModel")
self._props_['HeadModel'] = head_model.value.decode("utf-8")
# Determine hardware version.
plug_in_card_version = ctypes.c_uint()
flex_10k_file_version = ctypes.c_uint()
dummy1 = ctypes.c_uint()
dummy2 = ctypes.c_uint()
camera_firmware_version = ctypes.c_uint()
camera_firmware_build = ctypes.c_uint()
andorCheck(andor.GetHardwareVersion(ctypes.byref(plug_in_card_version),
ctypes.byref(flex_10k_file_version),
ctypes.byref(dummy1),
ctypes.byref(dummy2),
ctypes.byref(camera_firmware_version),
ctypes.byref(camera_firmware_build)),
"GetHardwareVersion")
self._props_["PlugInCardVersion"] = plug_in_card_version.value
self._props_["Flex10kFileVersion"] = flex_10k_file_version.value
self._props_["CameraFirmwareVersion"] = camera_firmware_version.value
self._props_["CameraFirmwareBuild"] = camera_firmware_build.value
# Determine vertical shift speeds.
number = ctypes.c_int()
andorCheck(andor.GetNumberVSSpeeds(ctypes.byref(number)), "GetNumberVSSpeeds")
self._props_["VSSpeeds"] = list(range(number.value))
for i in range(number.value):
index = ctypes.c_int(i)
speed = ctypes.c_float()
andorCheck(andor.GetVSSpeed(index, ctypes.byref(speed)), "GetVSSpeed")
self._props_["VSSpeeds"][i] = round(speed.value, 4)
# Determine horizontal shift speeds.
andorCheck(andor.GetNumberADChannels(ctypes.byref(number)), "GetNumberADChannels")
self._props_["NumberADChannels"] = number.value
self._props_["HSSpeeds"] = list(range(number.value))
for i in range(number.value):
channel = ctypes.c_int(i)
andorCheck(andor.GetNumberHSSpeeds(channel, 0, ctypes.byref(number)), "GetNumberHSSpeeds")
self._props_["HSSpeeds"][i] = list(range(number.value))
for j in range(number.value):
type = ctypes.c_int(j)
speed = ctypes.c_float()
andorCheck(andor.GetHSSpeed(channel, 0, type, ctypes.byref(speed)), "GetHSSpeed")
self._props_["HSSpeeds"][i][j] = round(speed.value, 4)
# Determine temperature range.
min_temp = ctypes.c_int()
max_temp = ctypes.c_int()
andorCheck(andor.GetTemperatureRange(ctypes.byref(min_temp), ctypes.byref(max_temp)), "GetTemperatureRange")
self._props_["TemperatureRange"] = [min_temp.value, max_temp.value]
# Determine preamp gains available.
number = ctypes.c_int()
andorCheck(andor.GetNumberPreAmpGains(ctypes.byref(number)), "GetNumberPreAmpGains")
self._props_["PreAmpGains"] = list(range(number.value))
for i in range(number.value):
index = ctypes.c_int(i)
gain = ctypes.c_float()
andorCheck(andor.GetPreAmpGain(index, ctypes.byref(gain)), "GetPreAmpGain")
self._props_["PreAmpGains"][i] = round(gain.value, 2)
# Determine EM gain range.
low = ctypes.c_int()
high = ctypes.c_int()
andorCheck(andor.GetEMGainRange(ctypes.byref(low), ctypes.byref(high)), "GetEMGainRange")
self._props_["EMGainRange"] = [low.value, high.value]
# Determine number of EM gain modes.
n_modes = 0
while (self.setEMGainMode(n_modes)):
n_modes += 1
self._props_["NumberEMGainModes"] = n_modes - 1
self.setEMGainMode(0)
# Determine the maximum binning values.
max_binning = ctypes.c_int()
andorCheck(andor.GetMaximumBinning(4, 0, ctypes.byref(max_binning)), "GetMaximumBinning")
self._props_["MaxBinning"] = [max_binning.value]
andorCheck(andor.GetMaximumBinning(4, 1, ctypes.byref(max_binning)), "GetMaximumBinning")
self._props_["MaxBinning"].append(max_binning.value)
# Determine maximum exposure time.
max_exp = ctypes.c_float()
andorCheck(andor.GetMaximumExposure(ctypes.byref(max_exp)), "GetMaximumExposure")
self._props_["MaxExposure"] = max_exp.value
def set_damping(p_state, damping, idx_image=-1, idx_chain=-1):
"""Set the Gilbert damping parameter [unitless]."""
_LLG_Set_Damping(ctypes.c_void_p(p_state), ctypes.c_float(damping),
ctypes.c_int(idx_image), ctypes.c_int(idx_chain))
def set_timestep(p_state, dt, idx_image=-1, idx_chain=-1):
"""Set the time step [ps] for the calculation."""
_LLG_Set_Time_Step(p_state, ctypes.c_float(dt), idx_image, idx_chain)
def setReservoirTsetColdSample(SetReservoirTsetColdSampleK):
"""
AttoDRY_Interface_setReservoirTsetColdSample
"""
ADRY.setReservoirTsetColdSample(
ctypes.c_float(SetReservoirTsetColdSampleK))
def setVTIHeaterPower(VTIHeaterPowerW):
"""
AttoDRY_Interface_setVTIHeaterPower
"""
ADRY.setVTIHeaterPower(ctypes.c_float(VTIHeaterPowerW))
def setReservoirTsetWarmSample(ReservoirTsetWarmSampleW):
"""
AttoDRY_Interface_setReservoirTsetWarmSample
"""
ADRY.setReservoirTsetWarmSample(
ctypes.c_float(ReservoirTsetWarmSampleW))
def setUserTemperature(Temperature):
"""
Sets the user temperature. This is the temperature used when temperature
control is enabled.
"""
ADRY.setUserTemperature(ctypes.c_float(Temperature))
def setReservoirTsetWarmMagnet(ReservoirTsetWarmMagnetW):
"""
AttoDRY_Interface_setReservoirTsetWarmMagnet
"""
ADRY.setReservoirTsetWarmMagnet(
ctypes.c_float(ReservoirTsetWarmMagnetW))
def art(data, theta, center, num_grid, iters, init_matrix):
"""
Applies Algebraic Reconstruction Technique (ART)
to obtain reconstructions.
Parameters
----------
data : ndarray, float32
3-D tomographic data with dimensions:
[projections, slices, pixels]
theta : ndarray, float32
Projection angles in radians.
center : scalar, float32
Pixel index corresponding to the
center of rotation axis.
num_grid : scalar, int32
Grid size of the econstructed images.
iters : scalar int32
Number of mlem iterations.
init_matrix : ndarray
Initial guess for the reconstruction. Its
shape is the same as the reconstructed data.
Returns
-------
output : ndarray
Reconstructed data with dimensions:
[slices, num_grid, num_grid]
References
----------
- `http://en.wikipedia.org/wiki/Algebraic_Reconstruction_Technique \
<http://en.wikipedia.org/wiki/Algebraic_Reconstruction_Technique>`_
- `http://en.wikipedia.org/wiki/Kaczmarz_method \
<http://en.wikipedia.org/wiki/Kaczmarz_method>`_
Examples
--------
- Reconstruct using ART:
>>> import tomopy
>>>
>>> # Load data
>>> myfile = 'demo/data.h5'
>>> data, white, dark, theta = tomopy.xtomo_reader(myfile, slices_start=0, slices_end=1)
>>>
>>> # Construct tomo object
>>> d = tomopy.xtomo_dataset(log='error')
>>> d.dataset(data, white, dark, theta)
>>> d.normalize()
>>> d.correct_drift()
>>> d.center = 662
>>>
>>> # Perform reconstruction
>>> d.art()
>>>
>>> # Save reconstructed data
>>> output_file='tmp/recon_'
>>> tomopy.xtomo_writer(d.data_recon, output_file)
>>> print "Images are succesfully saved at " + output_file + '...'
"""
num_projections = np.array(data.shape[0], dtype='int32')
num_slices = np.array(data.shape[1], dtype='int32')
num_pixels = np.array(data.shape[2], dtype='int32')
# Call C function.
c_float_p = ctypes.POINTER(ctypes.c_float)
librecon.art.restype = ctypes.POINTER(ctypes.c_void_p)
librecon.art(data.ctypes.data_as(c_float_p),
theta.ctypes.data_as(c_float_p), ctypes.c_float(center),
ctypes.c_int(num_projections), ctypes.c_int(num_slices),
ctypes.c_int(num_pixels), ctypes.c_int(num_grid),
ctypes.c_int(iters), init_matrix.ctypes.data_as(c_float_p))
return init_matrix
def setSampleHeaterPower(HeaterPowerW):
"""
Sets the sample heater value to the specified value
"""
ADRY.setSampleHeaterPower(ctypes.c_float(HeaterPowerW))
import ctypes as C
mate = C.CDLL('./mylib.so')
#=================================
# Suma de dos punto flotante de C.
#=================================
mate.add_float.restype = C.c_float #"Declaramos" que el resultado de llamar a la funcion es un punto flotante de C.
mate.add_float.argtypes = [
C.c_float, C.c_float
] #"Declaramos" que los argumnetos de la funcion son un punto flotante de C.
x_1 = C.c_float(1.1)
x_2 = C.c_float(10.10)
print 'add_float', mate.add_float(x_1, x_2)
# Suma de dos enteros de C.
math.add_int.restype = C.c_int #"Declaramos" que el resultado de llamar a la funcion es un entero de C.
math.add_int.argtypes = [
C.c_int, C.c_int
] #"Declaramos" que los argumnetos de la funcion son enteros de C.
n_1_1 = C.c_int(1)
n_2 = C.c_int(10)
print 'add_int', math.add_int(n_1, n_2)
# Suma de dos enteros C pasados por referencia.
x_1 = C.c_float(1.1)
x_2 = C.c_float(-0.10)
res = C.c_float()
mate.add_float_ref(C.byref(x_1), C.byref(x_2), C.byref(res))
def setUserMagneticField(MagneticField):
"""
Sets the user magntic field. This is used as the set point when field
control is active
"""
ADRY.setUserMagneticField(ctypes.c_float(MagneticField))
def _unpack_argument(self, ty, val, sycl_queue, kernelargs, device_arrs,
access_type):
"""
Unpacks the arguments that are to be passed to the SYCL kernel from
Numba types to Ctypes.
Args:
ty: The data types of the kernel argument defined as in instance of
numba.types.
val: The value of the kernel argument.
sycl_queue (dpctl.SyclQueue): A ``dpctl.SyclQueue`` object. The
queue object will be used whenever USM memory allocation is
needed during unpacking of an numpy.ndarray argument.
kernelargs (list): The list of kernel arguments into which the
current kernel argument will be appended.
device_arrs (list): A list of tuples that is used to store the
triples corresponding to the USM memorry allocated for an
``numpy.ndarray`` argument, a wrapper ``ndarray`` created from
the USM memory, and the original ``ndarray`` argument.
access_type : The type of access for an array argument.
Raises:
NotImplementedError: If the type of argument is not yet supported,
then a ``NotImplementedError`` is raised.
"""
device_arrs.append(None)
if isinstance(ty, USMNdArrayType):
self._unpack_device_array_argument(
val.size,
val.dtype.itemsize,
val.usm_data,
val.shape,
val.strides,
val.ndim,
kernelargs,
)
elif isinstance(ty, types.Array):
packed_val = val
usm_mem = has_usm_memory(val)
if usm_mem is None:
default_behavior = self.check_for_invalid_access_type(
access_type)
usm_mem = as_usm_obj(val, queue=sycl_queue, copy=False)
orig_val = val
packed = False
if not val.flags.c_contiguous:
# If the numpy.ndarray is not C-contiguous
# we pack the strided array into a packed array.
# This allows us to treat the data from here on as C-contiguous.
# While packing we treat the data as C-contiguous.
# We store the reference of both (strided and packed)
# array and during unpacking we use numpy.copyto() to copy
# the data back from the packed temporary array to the
# original strided array.
packed_val = val.flatten(order="C")
packed = True
if (default_behavior or self.valid_access_types[access_type]
== _NUMBA_DPPY_READ_ONLY
or self.valid_access_types[access_type]
== _NUMBA_DPPY_READ_WRITE):
copy_from_numpy_to_usm_obj(usm_mem, packed_val)
device_arrs[-1] = (usm_mem, orig_val, packed_val, packed)
self._unpack_device_array_argument(
packed_val.size,
packed_val.dtype.itemsize,
usm_mem,
packed_val.shape,
packed_val.strides,
packed_val.ndim,
kernelargs,
)
elif ty == types.int64:
cval = ctypes.c_longlong(val)
kernelargs.append(cval)
elif ty == types.uint64:
cval = ctypes.c_ulonglong(val)
kernelargs.append(cval)
elif ty == types.int32:
cval = ctypes.c_int(val)
kernelargs.append(cval)
elif ty == types.uint32:
cval = ctypes.c_uint(val)
kernelargs.append(cval)
elif ty == types.float64:
cval = ctypes.c_double(val)
kernelargs.append(cval)
elif ty == types.float32:
cval = ctypes.c_float(val)
kernelargs.append(cval)
elif ty == types.boolean:
cval = ctypes.c_uint8(int(val))
kernelargs.append(cval)
elif ty == types.complex64:
raise NotImplementedError(ty, val)
elif ty == types.complex128:
raise NotImplementedError(ty, val)
else:
raise NotImplementedError(ty, val)
# c_int int int/long
# c_uint unsigned int int/long
# c_long long int/long
# c_ulong unsigned long int/long
# c_longlong __int64 or longlong int/long
# c_ulonglong unsigned __int64 or unsigned long long int/long
# c_float float float
# c_double double float
# c_longdouble long double float float
# c_char_p char * string or None
# c_wchar_p wchar_t * unicode or None
# c_void_p void * int/long or None
import ctypes
gpio = ctypes.CDLL('./jetsongpio.so')
gpio.init_robot_gpio()
gpio.set_speed(ctypes.c_float(0.5))
gpio.go_straight()
gpio.go_straight_with_time(ctypes.c_uint(1))
gpio.go_back_with_time(ctypes.c_uint(1))
gpio.go_swerve_with_time(ctypes.c_uint(1), ctypes.c_uint(45))
# gpio.go_straight()
# gpio.go_back()
# gpio.go_speed(800, 250)
# gpio.go_swerve(800, 250)
gpio.go_stop()
# gpio.release_robot_gpio()
gpio.release_robot_gpio()
def run(self):
frameType = c_short * (self.height.value * self.width.value) #used for acquired frame
frameBuffer = frameType()
frameType = c_byte * (self.height.value * self.width.value) #used for streaming frame
frame8bit = frameType()
treePtr = c_void_p(0)
status = ZELOS2150GV.mdsLib.camOpenTree(c_char_p(self.device.getTree().name), c_int(self.device.getTree().shot), byref(treePtr))
if status == -1:
Data.execute('DevLogErr($1,$2)', self.device.getNid(), 'Cannot open tree')
raise mdsExceptions.TclFAILED_ESSENTIAL
if self.device.frame_sync.data() == 'EXTERNAL':
isExternal = 1
timebaseNid=self.device.frame_clock.getNid()
else:
isExternal = 0
timebaseNid=c_int(-1)
if self.device.streaming.data() == 'Stream and Store':
isStreaming = 1
isStorage = 1
if self.device.streaming.data() == 'Only Stream':
isStreaming = 1
isStorage = 0
if self.device.streaming.data() == 'Only Store':
isStreaming = 0
isStorage = 1
autoScale = self.device.stream_autos.data() #autoscaling pixel grey depth for streaming operation
if autoScale == 'YES':
autoScale=c_int(1)
else:
autoScale=c_int(0)
lowLim=c_int(self.device.stream_lolim.data())
highLim=c_int(self.device.stream_hilim.data())
minLim=c_int(0)
maxLim=c_int(32767)
tcpStreamHandle=c_int(-1)
streamPort=c_int(self.device.stream_port.data())
#frameTimeInt=0
prevFrameTime=0
totFrameTime=0
framePeriod = int(self.device.frame_period.data()*1000)
skipFrameStream=int(float(1/self.device.frame_period.data())/25.0)-1
print('skipFrameStream:',skipFrameStream)
if(skipFrameStream<0):
skipFrameStream=0
frameStreamCounter = skipFrameStream
frameTotalCounter = 0
status=c_int(-1)
self.idx = 0
while not self.stopReq:
ZELOS2150GV.kappaLib.kappaGetFrame(self.device.handle, byref(status), frameBuffer)
if status.value==3:
print('get frame timeout!')
else:
frameStreamCounter = frameStreamCounter + 1 #reset according to Stream decimation
frameTotalCounter = frameTotalCounter + 1 #never resetted
if isExternal==0: #internal clock source -> S.O. timestamp
timestamp=datetime.now()
frameTime=int(mktime(timestamp.timetuple())*1000)+int(timestamp.microsecond/1000) #ms
if frameTotalCounter==1:
prevFrameTime=int(mktime(timestamp.timetuple())*1000)+int(timestamp.microsecond/1000)
deltaT=frameTime-prevFrameTime
totFrameTime=0
else:
deltaT=frameTime-prevFrameTime
prevFrameTime=frameTime
totFrameTime=totFrameTime+deltaT
if (deltaT<framePeriod) and (deltaT>5):
sleep(float(framePeriod-deltaT)/1000.0)
#if( (isStorage==1) and ((status.value==1) or (status.value==2)) ): #frame complete or incomplete
if( (isStorage==1) and (status.value==1) ): #frame complete
ZELOS2150GV.mdsLib.camSaveFrame(frameBuffer, self.width, self.height, c_float(float(totFrameTime)/1000.0), c_int(14), treePtr, self.device.frames.getNid(), timebaseNid, c_int(frameTotalCounter-1), 0, 0, 0)
self.idx = self.idx + 1
print('saved frame idx:', self.idx)
if(isStreaming==1):
if(tcpStreamHandle.value==-1):
fede=ZELOS2150GV.streamLib.camOpenTcpConnection(streamPort, byref(tcpStreamHandle), self.width, self.height)
if(fede!=-1):
print('\nConnected to FFMPEG on localhost:',streamPort.value)
if(frameStreamCounter == skipFrameStream+1):
frameStreamCounter=0
if(frameStreamCounter == 0 and tcpStreamHandle.value!=-1):
ZELOS2150GV.streamLib.camFrameTo8bit(frameBuffer, self.width, self.height, frame8bit, autoScale, byref(lowLim), byref(highLim), minLim, maxLim)
ZELOS2150GV.streamLib.camSendFrameOnTcp(byref(tcpStreamHandle), self.width, self.height, frame8bit)
#endwhile
ZELOS2150GV.streamLib.camCloseTcpConnection(byref(tcpStreamHandle))
#print 'Stream Tcp Connection Closed'
status = ZELOS2150GV.kappaLib.kappaStopAcquisition(self.device.handle, self.hBuffers)
if status != 0:
Data.execute('DevLogErr($1,$2)', self.device.getNid(), 'Cannot stop camera acquisition')
#close device and remove from info
ZELOS2150GV.kappaLib.kappaClose(self.device.handle)
self.device.removeInfo()
raise mdsExceptions.TclFAILED_ESSENTIAL
def write_float(self, variable, value):
self.testlib.escreve_float(self.variable_float[variable],
ctypes.c_float(value))
def n_crit(self, value):
self._lib.set_n_crit(byref(c_float(value)))
def heatmap(self,
points,
dotsize=150,
opacity=128,
size=(1024, 1024),
scheme="classic",
area=None,
weighted=0,
srcepsg=None,
dstepsg='EPSG:3857'):
"""
points -> A representation of the points (x,y values) to process.
Can be a flattened array/tuple or any combination of 2 dimensional
array or tuple iterables i.e. [x1,y1,x2,y2], [(x1,y1),(x2,y2)], etc.
If weights are being used there are expected to be 3 'columns'
in the 2 dimensionable iterable or a multiple of 3 points in the
flat array/tuple i.e. (x1,y1,z1,x2,y2,z2), ([x1,y1,z1],[x2,y2,z2]) etc.
The third (weight) value can be anything but it is
best to have a normalised weight between 0 and 1.
For best performance, if convenient use a flattened array
as this is what is used internally and requires no conversion.
dotsize -> the size of a single coordinate in the output image in
pixels, default is 150px. Tweak this parameter to adjust
the resulting heatmap.
opacity -> the strength of a single coordiniate in the output image.
Tweak this parameter to adjust the resulting heatmap.
size -> tuple with the width, height in pixels of the output PNG
scheme -> Name of color scheme to use to color the output image.
Use schemes() to get list. (images are in source distro)
area -> Specify bounding coordinates of the output image. Tuple of
tuples: ((minX, minY), (maxX, maxY)). If None or unspecified,
these values are calculated based on the input data.
weighted -> Is the data weighted (0 or 1)
srcepsg -> epsg code of the source, set to None to ignore.
If using KML output make sure this is set otherwise either the image
or the overlay coordinates will be out.
dstepsg -> epsg code of the destination, ignored if srcepsg is not set.
Defaults to EPSG:3857 (Cylindrical Mercator).
Due to linear interpolation in heatmap.c it only makes sense to use linear
output projections. If outputting to KML for google earth client overlay use
EPSG:4087 (World Equidistant Cylindrical).
"""
self.dotsize = dotsize
self.opacity = opacity
self.size = size
self.points = points
self.weighted = weighted
self.srcepsg = srcepsg
self.dstepsg = dstepsg
if self.srcepsg and not use_pyproj:
raise Exception('srcepsg entered but pyproj is not available')
if area is not None:
self.area = area
self.override = 1
else:
self.area = ((0, 0), (0, 0))
self.override = 0
#convert area for heatmap.c if required
((east, south), (west, north)) = self.area
if use_pyproj and self.srcepsg is not None and self.srcepsg != self.dstepsg:
source = pyproj.Proj(init=self.srcepsg)
dest = pyproj.Proj(init=self.dstepsg)
(east, south) = pyproj.transform(source, dest, east, south)
(west, north) = pyproj.transform(source, dest, west, north)
if scheme not in self.schemes():
tmp = "Unknown color scheme: %s. Available schemes: %s" % (
scheme, self.schemes())
raise Exception(tmp)
arrPoints = self._convertPoints()
arrScheme = self._convertScheme(scheme)
arrFinalImage = self._allocOutputBuffer()
ret = self._heatmap.tx(arrPoints, len(arrPoints), size[0], size[1],
dotsize, arrScheme, arrFinalImage, opacity,
self.override, ctypes.c_float(east),
ctypes.c_float(south), ctypes.c_float(west),
ctypes.c_float(north), weighted)
if not ret:
raise Exception("Unexpected error during processing.")
self.img = Image.frombuffer('RGBA', (self.size[0], self.size[1]),
arrFinalImage, 'raw', 'RGBA', 0, 1)
return self.img
def xtr(self):
"""tuple(float, float): Top and bottom flow trip x/c locations."""
xtr_top = c_float()
xtr_bot = c_float()
self._lib.get_xtr(byref(xtr_top), byref(xtr_bot))
return float(xtr_top), float(xtr_bot)
def init(self):
global kappaLib
self.restoreInfo()
self.frames.setCompressOnPut(False)
status = ZELOS2150GV.kappaLib.kappaSetColorCoding(self.handle, c_int(6)) #Y14
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set Color Coding')
raise mdsExceptions.TclFAILED_ESSENTIAL
###Exposure Mode
if self.frame_sync.data() == 'EXTERNAL':
status = ZELOS2150GV.kappaLib.kappaSetExposureMode(self.handle, c_int(3)) #3 = ZELOS_ENUM_EXPOSUREMODE_RESETRESTART
else:
status = ZELOS2150GV.kappaLib.kappaSetExposureMode(self.handle, c_int(2)) #2 = ZELOS_ENUM_EXPOSUREMODE_FREERUNNINGSEQUENTIAL
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set Exposure Mode')
raise mdsExceptions.TclFAILED_ESSENTIAL
###Exposure
autoExp = self.auto_exp.data()
if autoExp == 'YES':
status = ZELOS2150GV.kappaLib.kappaSetAET(self.handle, c_int(1))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set AET On')
raise mdsExceptions.TclFAILED_ESSENTIAL
status = ZELOS2150GV.kappaLib.kappaSetAutoExposureLevel(self.handle, c_int(self.exp_lev.data()))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set Auto Exposure Level')
raise mdsExceptions.TclFAILED_ESSENTIAL
else:
status = ZELOS2150GV.kappaLib.kappaSetAET(self.handle, c_int(0))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set AET Off')
raise mdsExceptions.TclFAILED_ESSENTIAL
status = ZELOS2150GV.kappaLib.kappaSetExposure(self.handle, c_float(self.exp_time.data()))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set Exposure Time')
raise mdsExceptions.TclFAILED_ESSENTIAL
###Gain
autoGain = self.auto_gain.data()
if autoGain == 'YES':
status = ZELOS2150GV.kappaLib.kappaSetAGC(self.handle, c_int(1))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set AGC On')
raise mdsExceptions.TclFAILED_ESSENTIAL
else:
status = ZELOS2150GV.kappaLib.kappaSetAGC(self.handle, c_int(0))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set AGC On')
raise mdsExceptions.TclFAILED_ESSENTIAL
status = ZELOS2150GV.kappaLib.kappaSetGain(self.handle, c_int(self.gain_lev.data()))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set Gain')
raise mdsExceptions.TclFAILED_ESSENTIAL
###Slow Scan
slowScan = self.slow_scan.data()
if slowScan == 'YES':
status = ZELOS2150GV.kappaLib.kappaSetSlowScan(self.handle, c_int(1))
else:
status = ZELOS2150GV.kappaLib.kappaSetSlowScan(self.handle, c_int(0))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set Slow Scan')
raise mdsExceptions.TclFAILED_ESSENTIAL
###Frame Area
status = ZELOS2150GV.kappaLib.kappaSetReadoutArea(self.handle, c_int(self.frame_x.data()),c_int(self.frame_y.data()),c_int(self.frame_width.data()),c_int(self.frame_height.data()))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set Readout Area')
raise mdsExceptions.TclFAILED_ESSENTIAL
###Measure Area
status = ZELOS2150GV.kappaLib.kappaSetMeasureWindow(self.handle, c_int(self.meas_x.data()),c_int(self.meas_y.data()),c_int(self.meas_width.data()),c_int(self.meas_height.data()))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot Set Measure Window')
raise mdsExceptions.TclFAILED_ESSENTIAL
###Binning
status = ZELOS2150GV.kappaLib.kappaSetBinning(self.handle, c_int(self.hor_binning), c_int(self.ver_binning))
if status < 0:
Data.execute('DevLogErr($1,$2)', self.getNid(), 'Cannot set horizontal or vertical binning')
raise mdsExceptions.TclFAILED_ESSENTIAL
self.saveInfo()
return
def Re(self, value):
self._lib.set_reynolds(byref(c_float(value)))
def xtr(self, value):
self._lib.set_xtr(byref(c_float(value[0])), byref(c_float(value[1])))
"""ctypes single-value "parameter" arguments (e.g. byref)
"""
REGISTRY_NAME = 'ctypeparameter'
import ctypes, _ctypes
from OpenGL import constants, constant
from OpenGL.arrays import formathandler
import operator
c = ctypes.c_float(0)
ParamaterType = ctypes.byref(c).__class__
DIRECT_RETURN_TYPES = (
ParamaterType,
# these pointer types are implemented as _SimpleCData
# despite being pointers...
ctypes.c_void_p,
ctypes.c_char_p,
ctypes.c_wchar_p,
)
try:
del c
except NameError as err:
pass
class CtypesParameterHandler(formathandler.FormatHandler):
"""Ctypes Paramater-type-specific data-type handler for OpenGL"""
isOutput = True
HANDLED_TYPES = (ParamaterType, _ctypes._SimpleCData)
def from_param(cls, value, typeCode=None):
def M(self, value):
self._lib.set_mach(byref(c_float(value)))
def main():
read_mode_top = 4 # readout mode options: 0 Full Vertical binning; 1 Multi-Track; 2 Random-Track; 3 Single-Track; 4 Image;
# Load the atmcd64.dll file
andor_dll = ctypes.cdll.atmcd64d
# Initialize camera
aBuffer = ctypes.c_char_p() # The buffer tells the initialize function where the driver files are. Currently, they're in the same folder as this .py file
error_value = andor_dll.Initialize(aBuffer)
check_success(error_value, "Initialize")
# Determine size (in pixels of camera)
gblXPixels = ctypes.c_int() # Total number of horizontal pixels
gblYPixels = ctypes.c_int() # Total number of vertical pixels
error_value = andor_dll.GetDetector(ctypes.byref(gblXPixels),ctypes.byref(gblYPixels))
check_success(error_value,"GetDetector")
# Set vertical shift speed to recommended value
vertical_shift_index = ctypes.c_int() # the index to access specific vertical shift speeds
vertical_speed = ctypes.c_float() # speed of the vertical speed shift in microseconds per pixel shift
error_value = andor_dll.GetFastestRecommendedVSSpeed(ctypes.byref(vertical_shift_index),ctypes.byref(vertical_speed))
check_success(error_value,"Get Fastest Recommended Vertical Shift Speed")
error_value = andor_dll.SetVSSpeed(vertical_shift_index)
check_success(error_value,"Set Vertical Shift Speed")
# Set horizontal shift speed to the maximum
horizontal_shift_index = ctypes.c_int(0) # the index to access specific horizontal shift speeds
AD_converter_index = ctypes.c_int() # the specific index to access a given A-D converter
number_AD = ctypes.c_int(0) # the number of A-D converters in the camera
number_speeds = ctypes.c_int() # number of speeds available
horizontal_speed = ctypes.c_float() # horizontal shift speed
max_horizontal_speed = ctypes.c_float(0) # maximum horizontal speed
error_value = andor_dll.GetNumberADChannels(ctypes.byref(number_AD))
check_success(error_value,"Get Number AD Channels")
for each_AD in range(number_AD.value):
error_value = andor_dll.GetNumberHSSpeeds(AD_converter_index, ctypes.c_int(0), ctypes.byref(number_speeds))
check_success(error_value, "Get Number Horizontal Shift Speeds")
for each_speed_index in range(number_speeds.value):
error_value = andor_dll.GetHSSpeed(ctypes.c_int(each_AD),ctypes.c_int(0),ctypes.c_int(each_speed_index),ctypes.byref(horizontal_speed))
check_success(error_value,"Get Horizontal Shift Speed")
if (horizontal_speed.value > max_horizontal_speed.value):
max_horizontal_speed.value = horizontal_speed.value
horizontal_shift_index = ctypes.c_int(each_speed_index)
AD_converter_index = ctypes.c_int(each_AD)
error_value = andor_dll.SetADChannel(AD_converter_index)
check_success(error_value,"Set AD Channel")
error_value = andor_dll.SetHSSpeed(ctypes.c_int(0), horizontal_shift_index)
check_success(error_value, "Set Horizontal Speed Index")
# Turn the camera cooler on
error_value = andor_dll.CoolerON()
check_success(error_value,"Turn Cooler On")
# Check to make sure cooler is on
cooler_on = ctypes.c_int()
error_value = andor_dll.IsCoolerOn(ctypes.byref(cooler_on))
check_success(error_value, "Check if cooler is on")
if (cooler_on.value != 1):
print("Error: Cooler not on", "Exiting...")
return False #TODO: exit code or somethings
# Set the readout mode of the camera
read_mode = ctypes.c_int(read_mode_top) # readout mode options: 0 Full Vertical binning; 1 Multi-Track; 2 Random-Track; 3 Single-Track; 4 Image;
error_value = andor_dll.SetReadMode(read_mode)
check_success(error_value,"Set Read Mode")
# Set the acquisition mode
acquisition_mode = ctypes.c_int(1) # acquisition mode options: 1 Single scan; 2 Accumulate; 3 Kinetics; 4 Fast Kinetics; 5 Run till abort;
error_value = andor_dll.SetAcquisitionMode(acquisition_mode)
check_success(error_value,"Set Acquisition Mode")
# Set exposure time
exposure_time = ctypes.c_float(0.1) # time in seconds
error_value = andor_dll.SetExposureTime(exposure_time)
check_success(error_value, "Set Exposure Time")
# Set trigger mode
trigger_mode = ctypes.c_int(0) # trigger mode options: 0 internal; 1 external; 6 external start; 7 external exposure (bulb); 9 external FVB EM; 10 software trigger; 12 external charge shifting;
error_value = andor_dll.SetTriggerMode(trigger_mode)
check_success(error_value, "Set Trigger Mode")
# TODO Set up accumulation and kinetic capture & probs not video
"""
// only needed for accumulation acquisition
//float accumulation_cycle_time = .1; // seconds
//errorValue = SetAccumulationCycleTime(accumulation_cycle_time);
//if (errorValue != DRV_SUCCESS) {
//std::cout << "Set accumulation cycle time Error\n";
//std::cout << "Error: " << errorValue << "\n";
//}
//Only needed for kinetic capture
//errorValue = SetBaselineClamp(1);
//if (errorValue != DRV_SUCCESS) {
//std::cout << "Set Baseline Clamp Error\n";
//std::cout << "Error: " << errorValue << "\n";
//}
"""
# Determine the actual times the camera is using for acquisition
actual_exposure_time = ctypes.c_float()
actual_accumulate_time = ctypes.c_float()
actual_kinetic_time = ctypes.c_float()
error_value = andor_dll.GetAcquisitionTimings(ctypes.byref(actual_exposure_time),ctypes.byref(actual_accumulate_time),ctypes.byref(actual_kinetic_time))
check_success(error_value, "Get Acquisition Timings")
# Wait for two seconds to allow the camera to calibrate fully before starting acquisition
time.sleep(2)
# Make sure the camera is in an idle state before starting an acquisition
camera_status = ctypes.c_int()
error_value = andor_dll.GetStatus(ctypes.byref(camera_status))
check_success(error_value, "Get Camera Status")
while (camera_status.value != 20073):
error_value = andor_dll.GetStatus(ctypes.byref(camera_status))
check_success(error_value, "Get Camera Status")
#print("Camera Status is ", camera_status.value)
# Set the horizontal and vertical binning and the area of the image to be captured
horizontal_binning = ctypes.c_int(1) # Number of pixels to bin horizontally
vertical_binning = ctypes.c_int(1) # Number of pixels to bin vertically
horizontal_start = ctypes.c_int(1) # Start column of image to be taken (inclusive)
horizontal_end = gblXPixels # End column of image to be taken (inclusive)
vertical_start = ctypes.c_int(1) # Start row of image to be taken (inclusive)
vertical_end = gblYPixels # End row of image to be taken (inclusive)
error_value = andor_dll.SetImage(horizontal_binning, vertical_binning, horizontal_start, horizontal_end, vertical_start, vertical_end);
check_success(error_value, "Set Image")
# Start the acquisition process
error_value = andor_dll.StartAcquisition()
acquiring = check_success(error_value, "Start Acquisition")
if (acquiring == False):
andor_dll.AbortAcquisition()
else:
print("Starting Acquisition")
# Wait until the acquisition is complete
error_value = andor_dll.GetStatus(ctypes.byref(camera_status))
check_success(error_value, "Get Camera Status")
while (camera_status.value != 20073):
error_value = andor_dll.GetStatus(ctypes.byref(camera_status))
check_success(error_value, "Get Camera Status")
#print("Camera Status is ", camera_status.value)
# Get the image data from the camera
size = ctypes.c_int(gblXPixels.value*gblYPixels.value)
image_pointer = ctypes.cast(ctypes.create_string_buffer( size.value*ctypes.sizeof(ctypes.c_long()) ),ctypes.POINTER(ctypes.c_long))
error_value = andor_dll.GetAcquiredData(image_pointer, size)
check_success(error_value, "Get Acquired Data")
# Transfer the image from a pointer to a numpy array
image = np.zeros((gblYPixels.value,gblXPixels.value))
for x in range(gblXPixels.value):
for y in range(gblYPixels.value):
image[y,x] = image_pointer[x + y*gblXPixels.value]
plt.imsave('filename.png', image, cmap=cm.gray)
# Shut down camera
error_value = andor_dll.ShutDown()
check_success(error_value, "Shut down")
assert_pico_ok(status["trigger"])
# Set number of pre and post trigger samples to be collected
preTriggerSamples = 2500
postTriggerSamples = 2500
maxSamples = preTriggerSamples + postTriggerSamples
# Get timebase information
# handle = chandle
timebase = 8
# noSamples = maxSamples
# pointer to timeIntervalNanoseconds = ctypes.byref(timeIntervalns)
oversample = 1
# pointer to maxSamples = ctypes.byref(returnedMaxSamples)
# segment index = 0
timeIntervalns = ctypes.c_float()
returnedMaxSamples = ctypes.c_int32()
status["getTimebase"] = ps.ps5000GetTimebase(chandle, timebase, maxSamples,
ctypes.byref(timeIntervalns),
oversample,
ctypes.byref(returnedMaxSamples),
0)
assert_pico_ok(status["getTimebase2"])
# Run block capture
# handle = chandle
# number of pre-trigger samples = preTriggerSamples
# number of post-trigger samples = PostTriggerSamples
# timebase = 8 = 80 ns (see Programmer's guide for mre information on timebases)
# oversample = 1
# time indisposed ms = None (not needed in the example)
