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 + "()"; }