bp::object FiltMed(bp::object in_obj, bp::object k_size, bp::object channel_obj) {
Img in, out;
in.CopyFromPyArrayObject(reinterpret_cast<PyArrayObject*>(in_obj.ptr()));
int k_height = bp::extract<int>(k_size[0]);
int k_width = bp::extract<int>(k_size[1]);
int channel = bp::extract<int>(channel_obj);
FiltMedImg(in, k_width, k_height, channel, out);
PyObject* out_obj =(PyObject*) out.ToPyArrayObject();
bp::handle<> out_handle(out_obj);
bp::numeric::array out_array(out_handle);
return out_array.copy();
}
//-----------------------------------------------------------------------------
// Purpose: Called when it's time for a physically moved objects (plats, doors, etc)
// to run it's game code.
// All other entity thinking is done during worldspawn's think
//-----------------------------------------------------------------------------
void C_BaseEntity::PhysicsPyDispatchThink( bp::object thinkFunc )
{
float thinkLimit = think_limit.GetFloat();
float startTime = 0.0;
/*
// This doesn't apply on the client, really
if ( IsDormant() )
{
Warning( "Dormant entity %s is thinking!!\n", GetClassname() );
Assert(0);
}
*/
if ( thinkLimit )
{
startTime = Plat_FloatTime();
}
if ( thinkFunc.ptr() != Py_None )
{
try {
thinkFunc();
} catch(boost::python::error_already_set &) {
PyErr_Print();
}
}
if ( thinkLimit )
{
// calculate running time of the AI in milliseconds
float time = ( Plat_FloatTime() - startTime ) * 1000.0f;
if ( time > thinkLimit )
{
#if 0
// If its an NPC print out the shedule/task that took so long
CAI_BaseNPC *pNPC = MyNPCPointer();
if (pNPC && pNPC->GetCurSchedule())
{
pNPC->ReportOverThinkLimit( time );
}
else
#endif
{
Msg( "CLIENT: %s(%s) thinking for %.02f ms!!!\n", GetClassname(), typeid(this).raw_name(), time );
}
}
}
}
inline
bool
is_object_of_type(
bp::object const & obj
, PyTypeObject & type_obj0
, PyTypeObject & type_obj1
)
{
if( PyObject_TypeCheck(obj.ptr(), &type_obj0)
|| PyObject_TypeCheck(obj.ptr(), &type_obj1)
)
{
return true;
}
return false;
}
static size_t wrap_send(uhd::tx_streamer *tx_stream,
bp::object &np_array,
bp::object &metadata,
const double timeout = 0.1)
{
// Extract the metadata
bp::extract<uhd::tx_metadata_t&> get_metadata(metadata);
// TODO: throw an error here?
if (not get_metadata.check())
{
return 0;
}
// Get a numpy array object from given python object
// No sanity checking possible!
// Note: this increases the ref count, which we'll need to manually decrease at the end
PyObject* array_obj = PyArray_FROM_OF(np_array.ptr(),NPY_ARRAY_CARRAY);
PyArrayObject* array_type_obj = reinterpret_cast<PyArrayObject*>(array_obj);
// Get dimensions of the numpy array
const size_t dims = PyArray_NDIM(array_type_obj);
const npy_intp* shape = PyArray_SHAPE(array_type_obj);
// How many bytes to jump to get to the next element of the stride
// (next row)
const npy_intp* strides = PyArray_STRIDES(array_type_obj);
const size_t channels = tx_stream->get_num_channels();
// Check if numpy array sizes are ok
if (((channels > 1) && (dims != 2))
or ((size_t) shape[0] < channels))
{
// Manually decrement the ref count
Py_DECREF(array_obj);
// If we don't have a 2D NumPy array, assume we have a 1D array
size_t input_channels = (dims != 2) ? 1 : shape[0];
throw uhd::runtime_error(str(boost::format(
"Number of TX channels (%d) does not match the dimensions of the data array (%d)")
% channels % input_channels));
}
// Get a pointer to the storage
std::vector<void*> channel_storage;
char* data = PyArray_BYTES(array_type_obj);
for (size_t i = 0; i < channels; ++i)
{
channel_storage.push_back((void*)(data + i * strides[0]));
}
// Get data buffer and size of the array
size_t nsamps_per_buff = (dims > 1) ? (size_t) shape[1] : PyArray_SIZE(array_type_obj);
// Release the GIL only for the send() call
const size_t result = [&]() {
scoped_gil_release gil_release;
// Call the real send()
return tx_stream->send(
channel_storage,
nsamps_per_buff,
get_metadata(),
timeout
);
}();
// Manually decrement the ref count
Py_DECREF(array_obj);
return result;
}
string _Repr(bp::object const &self, string const &prefix) {
string name(bp::extract<string>(self.attr("__class__").attr("__name__")));
return prefix + name + "()";
}