int PseudoReplicatorGadget::process(GadgetContainerMessage<IsmrmrdReconData>* m) {
std::mt19937 engine;
std::normal_distribution<float> distribution;
auto m_copy = *m->getObjectPtr();
//First just send the normal data to obtain standard image
if (this->next()->putq(m) == GADGET_FAIL)
return GADGET_FAIL;
//Now for the noisy projections
for (int i =0; i < repetitions_; i++){
auto cm = new GadgetContainerMessage<IsmrmrdReconData>();
*cm->getObjectPtr() = m_copy;
auto & datasets = cm->getObjectPtr()->rbit_;
for (auto & buffer : datasets){
auto & data = buffer.data_.data_;
auto dataptr = data.get_data_ptr();
for (size_t k =0; k < data.get_number_of_elements(); k++){
dataptr[k] += std::complex<float>(distribution(engine),distribution(engine));
}
}
GDEBUG("Sending out Pseudoreplica\n");
if (this->next()->putq(cm) == GADGET_FAIL)
return GADGET_FAIL;
}
return GADGET_OK;
}
hx::Object *CppiaCtx::runObjectPtr(void *vtable)
{
if (breakContReturn) return 0;
GET_RETURN_VAL(return getObjectPtr(),etObject );
//printf("No Object return?\n");
return 0;
}
IAnimCtrl *USkeleton::getBoneAnimCtrl(uint boneId) const
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
return object->getBoneAnimCtrl(boneId);
}
int DistributeGadget::close(unsigned long flags)
{
int ret = Gadget::close(flags);
if (flags) {
mtx_.acquire();
for (auto n = node_map_.begin(); n != node_map_.end(); n++) {
if (n->second) {
auto m1 = new GadgetContainerMessage<GadgetMessageIdentifier>();
m1->getObjectPtr()->id = GADGET_MESSAGE_CLOSE;
if (n->second->putq(m1) == -1) {
GERROR("Unable to put CLOSE package on queue\n");
return -1;
}
}
}
auto it = node_map_.begin();
while (it != node_map_.end()) {
if (it->second) {
it->second->wait();
delete it->second;
}
node_map_.erase(it);
it = node_map_.begin();
}
mtx_.release();
GDEBUG("All connectors closed. Waiting for Gadget to close\n");
}
return ret;
}
void USkeleton::setBoneAnimCtrl(uint boneId, IAnimCtrl *ctrl)
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
object->setBoneAnimCtrl(boneId, ctrl);
}
bool USkeleton::isBoneComputed(uint boneId) const
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
return object->isBoneComputed(boneId);
}
void USkeleton::computeLodTexture()
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
object->computeLodTexture();
}
bool USkeleton::forceComputeBone(uint boneId)
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
return object->forceComputeBone(boneId);
}
void USkeleton::setInterpolationDistance(float dist)
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
object->setInterpolationDistance(dist);
}
sint USkeleton::getBoneIdByName(const std::string &boneName) const
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
return object->getBoneIdByName(boneName);
}
float USkeleton::getInterpolationDistance() const
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
return object->getInterpolationDistance();
}
uint USkeleton::getNumBoneComputed() const
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
return object->getNumBoneComputed();
}
UBone USkeleton::getBone(uint boneId) const
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
if(boneId>=object->Bones.size())
nlerror("getBone(): bad boneId");
return UBone (&(object->Bones[boneId]));
}
// ***************************************************************************
void UTransform::unfreezeHRC()
{
CTransform *object = getObjectPtr();
while (object)
{
object->unfreezeHRC();
object = object->hrcGetParent();
}
}
void USkeleton::stickObjectEx(UTransform mi, uint boneId, bool forceCLod)
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
if(mi.empty())
nlerror("USkeleton::stickObject(): mi is NULL");
CTransform *trans= dynamic_cast<CTransform*>(mi.getObjectPtr());
object->stickObjectEx(trans, boneId, forceCLod);
}
void USkeleton::detachSkeletonSon(UTransform mi)
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
if(mi.empty())
nlerror("USkeleton::detachSkeletonSon(): mi is NULL");
CTransform *trans= dynamic_cast<CTransform*>(mi.getObjectPtr());
object->detachSkeletonSon(trans);
}
void USkeleton::setShapeDistMax(float distMax)
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
if(object && object->Shape)
{
object->Shape->setDistMax(distMax);
}
}
// ***************************************************************************
UInstanceGroup *UTransform::getClusterSystem () const
{
CTransform *object = getObjectPtr();
CInstanceGroup *ig= object->getClusterSystem();
if(ig==((CInstanceGroup*)-1))
return ((UInstanceGroup*)-1);
else if(ig==NULL)
return NULL;
else
return ig->getUserInterface();
}
float USkeleton::getShapeDistMax() const
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
if(object && object->Shape)
{
return object->Shape->getDistMax();
}
else
return -1;
}
bool USkeleton::computeCurrentBBox(NLMISC::CAABBox &bbox, UPlayList *playList, double playTime, bool forceCompute /* = false */, bool computeInWorld)
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
if(playList!=NULL)
{
CPlayListUser *plUser= static_cast<CPlayListUser*>(playList);
plUser->evalPlayList(playTime);
}
return object->computeCurrentBBox(bbox, forceCompute, computeInWorld);
}
int GadgetInstrumentationStreamController::return_recondata(ACE_Message_Block* mb){
GILLock lock;
auto m1 = AsContainerMessage<IsmrmrdReconData>(mb);
try{
python_gadget_.attr("put_next")(*m1->getObjectPtr());
} catch(boost::python::error_already_set const &) {
GERROR("Passing recondata on to python wrapper gadget failed\n");
std::string python_error = pyerr_to_string();
GDEBUG(python_error.c_str());
return GADGET_FAIL;
}
return GADGET_OK;
}
// ***************************************************************************
void USkeleton::getStickedObjects(std::vector<UTransform> &sticks)
{
NL3D_HAUTO_UI_SKELETON;
sticks.clear();
CSkeletonModel *sm= getObjectPtr();
if(!sm)
return;
const std::set<CTransform*> &stickSet= sm->getStickedObjects();
std::set<CTransform*>::const_iterator it= stickSet.begin();
sticks.reserve(stickSet.size());
for(;it!=stickSet.end();it++)
{
sticks.push_back(*it);
}
}
bool USkeleton::bindSkin(UInstance mi)
{
NL3D_HAUTO_UI_SKELETON;
if(mi.empty())
{
nlerror("USkeleton::bindSkin(): mi is NULL");
return false;
}
CTransform *trans= dynamic_cast<CTransform*>(mi.getObjectPtr());
CMeshBaseInstance *meshi= dynamic_cast<CMeshBaseInstance*>(trans);
if(meshi==NULL)
{
nlerror("USkeleton::bindSkin(): mi is not a MeshInstance or MeshMRMInstance");
return false;
}
CSkeletonModel *object = getObjectPtr();
return object->bindSkin(meshi);
}
// ***************************************************************************
void UTransform::setClusterSystem (UInstanceGroup *pIG)
{
NL3D_HAUTO_SET_CLUSTER_SYSTEM
CTransform *object = getObjectPtr();
if (object->getForceClipRoot())
{
nlwarning("Transform has been flagged to be glued to the root, and thus can't be clusterized. See UTransform::setForceClipRoot(bool).");
return;
}
if ((pIG == NULL) || (pIG == (UInstanceGroup*)-1))
{
if (pIG == NULL)
object->setClusterSystem (NULL);
else
object->setClusterSystem ((CInstanceGroup*)-1);
}
else
object->setClusterSystem (&((CInstanceGroupUser*)pIG)->getInternalIG());
}
// ***************************************************************************
void UTransform::parent(UTransform newFather)
{
CTransform *object = getObjectPtr();
if (object->getForceClipRoot())
{
nlwarning("Transform has been flagged to be glued to the root, can't change parent. See UTransform::setForceClipRoot(bool).");
return;
}
if(!newFather.empty())
{
// link me to other.
CTransform *other= newFather.getObjectPtr();
if(other->getOwnerScene()!=object->getOwnerScene())
nlerror("Try to parent 2 object from 2 differnet scenes!!");
other->hrcLinkSon( object );
}
else
{
// link me to Root.
object->getOwnerScene()->getRoot()->hrcLinkSon( object );
}
}
// ***************************************************************************
void UTransform::getLastParentClusters(std::vector<CCluster*> &clusters) const
{
CTransform *object = getObjectPtr();
CScene *scene = object->getOwnerScene();
// look in the list of parent of the transform object and extract the CCluster parents
if (scene == NULL)
return;
CClipTrav &clipTrav= scene->getClipTrav();
uint num= object->clipGetNumParents();
for(uint i=0;i<num;i++)
{
CCluster *pcluster = dynamic_cast<CCluster*>(object->clipGetParent(i));
if (pcluster != NULL)
clusters.push_back(pcluster);
}
// If the object is link to a QuadCluster, add the RootCluster to the list
CTransformShape *trShp= dynamic_cast<CTransformShape*>( object );
if( trShp && trShp->isLinkToQuadCluster() )
clusters.push_back(clipTrav.RootCluster);
}
// ***************************************************************************
const std::string &USkeleton::getShapeName() const
{
NL3D_HAUTO_UI_SKELETON;
static std::string emptyStr;
CSkeletonModel *object = getObjectPtr();
if(!object)
return emptyStr;
// get the shape bank
CScene *scene= object->getOwnerScene();
CShapeBank *sb= scene->getShapeBank();
if(!sb)
return emptyStr;
// get the shape name
const std::string *str= sb->getShapeNameFromShapePtr(object->Shape);
if(str)
return *str;
else
return emptyStr;
}
// ***************************************************************************
NLMISC::CRGBA USkeleton::getLodEmit() const
{
return getObjectPtr()->getLodEmit();
}
// ***************************************************************************
void USkeleton::setLodEmit(NLMISC::CRGBA emit)
{
getObjectPtr()->setLodEmit(emit);
}
// ***************************************************************************
const NLMISC::CVector &USkeleton::getSSSWODir() const
{
NL3D_HAUTO_UI_SKELETON;
CSkeletonModel *object = getObjectPtr();
return object->getSSSWODir();
}
