FCIMPLEND
FCIMPL1(Object*, AssemblyNameNative::ToString, Object* refThisUNSAFE)
{
FCALL_CONTRACT;
OBJECTREF pObj = NULL;
ASSEMBLYNAMEREF pThis = (ASSEMBLYNAMEREF) (OBJECTREF) refThisUNSAFE;
HELPER_METHOD_FRAME_BEGIN_RET_1(pThis);
if (pThis == NULL)
COMPlusThrow(kNullReferenceException, W("NullReference_This"));
Thread *pThread = GetThread();
CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
AssemblySpec spec;
spec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &pThis, FALSE, FALSE);
StackSString name;
#ifndef FEATURE_FUSION
spec.GetFileOrDisplayName(ASM_DISPLAYF_VERSION |
ASM_DISPLAYF_CULTURE |
ASM_DISPLAYF_PUBLIC_KEY_TOKEN,
name);
#else
spec.GetFileOrDisplayName(0, name);
#endif // FEATURE_FUSION
pObj = (OBJECTREF) StringObject::NewString(name);
HELPER_METHOD_FRAME_END();
return OBJECTREFToObject(pObj);
}
FCIMPLEND
/// "parse" tells us to parse the simple name of the assembly as if it was the full name
/// almost never the right thing to do, but needed for compat
/* static */
FCIMPL3(FC_BOOL_RET, AssemblyNameNative::ReferenceMatchesDefinition, AssemblyNameBaseObject* refUNSAFE, AssemblyNameBaseObject* defUNSAFE, CLR_BOOL fParse)
{
FCALL_CONTRACT;
struct _gc
{
ASSEMBLYNAMEREF pRef;
ASSEMBLYNAMEREF pDef;
} gc;
gc.pRef = (ASSEMBLYNAMEREF)ObjectToOBJECTREF (refUNSAFE);
gc.pDef = (ASSEMBLYNAMEREF)ObjectToOBJECTREF (defUNSAFE);
BOOL result = FALSE;
HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
Thread *pThread = GetThread();
CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
if (gc.pRef == NULL)
COMPlusThrow(kArgumentNullException, W("ArgumentNull_AssemblyName"));
if (gc.pDef == NULL)
COMPlusThrow(kArgumentNullException, W("ArgumentNull_AssemblyName"));
AssemblySpec refSpec;
refSpec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &gc.pRef, fParse, FALSE);
AssemblySpec defSpec;
defSpec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &gc.pDef, fParse, FALSE);
#ifdef FEATURE_FUSION
SafeComHolder<IAssemblyName> pRefName (NULL);
IfFailThrow(refSpec.CreateFusionName(&pRefName, FALSE));
SafeComHolder <IAssemblyName> pDefName (NULL);
IfFailThrow(defSpec.CreateFusionName(&pDefName, FALSE));
// Order matters: Ref->IsEqual(Def)
result = (S_OK == pRefName->IsEqual(pDefName, ASM_CMPF_IL_ALL));
#else
result=AssemblySpec::RefMatchesDef(&refSpec,&defSpec);
#endif
HELPER_METHOD_FRAME_END();
FC_RETURN_BOOL(result);
}
FCIMPLEND
#endif // !FEATURE_CORECLR
FCIMPL4(void, AssemblyNameNative::Init, Object * refThisUNSAFE, OBJECTREF * pAssemblyRef, CLR_BOOL fForIntrospection, CLR_BOOL fRaiseResolveEvent)
{
FCALL_CONTRACT;
ASSEMBLYNAMEREF pThis = (ASSEMBLYNAMEREF) (OBJECTREF) refThisUNSAFE;
HRESULT hr = S_OK;
HELPER_METHOD_FRAME_BEGIN_1(pThis);
*pAssemblyRef = NULL;
if (pThis == NULL)
COMPlusThrow(kNullReferenceException, W("NullReference_This"));
Thread * pThread = GetThread();
CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
AssemblySpec spec;
hr = spec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF *) &pThis, TRUE, FALSE);
if (SUCCEEDED(hr))
{
spec.AssemblyNameInit(&pThis,NULL);
}
else if ((hr == FUSION_E_INVALID_NAME) && fRaiseResolveEvent)
{
Assembly * pAssembly = GetAppDomain()->RaiseAssemblyResolveEvent(&spec, fForIntrospection, FALSE);
if (pAssembly == NULL)
{
EEFileLoadException::Throw(&spec, hr);
}
else
{
*((OBJECTREF *) (&(*pAssemblyRef))) = pAssembly->GetExposedObject();
}
}
else
{
ThrowHR(hr);
}
HELPER_METHOD_FRAME_END();
}
///Randomly rotate sgrid_m
void NonLocalECPComponent::randomize_grid(ParticleSet::ParticlePos_t& sphere, bool randomize)
{
if(randomize) {
//const RealType twopi(6.28318530718);
//RealType phi(twopi*Random()),psi(twopi*Random()),cth(Random()-0.5),
RealType phi(TWOPI*((*myRNG)())), psi(TWOPI*((*myRNG)())), cth(((*myRNG)())-0.5);
RealType sph(std::sin(phi)),cph(std::cos(phi)),
sth(std::sqrt(1.0-cth*cth)),sps(std::sin(psi)),
cps(std::cos(psi));
TensorType rmat( cph*cth*cps-sph*sps, sph*cth*cps+cph*sps,-sth*cps,
-cph*cth*sps-sph*cps,-sph*cth*sps+cph*cps, sth*sps,
cph*sth, sph*sth, cth );
SpherGridType::iterator it(sgridxyz_m.begin());
SpherGridType::iterator it_end(sgridxyz_m.end());
SpherGridType::iterator jt(rrotsgrid_m.begin());
int ic=0;
while(it != it_end) {*jt = dot(rmat,*it); ++it; ++jt;}
//copy the radomized grid to sphere
std::copy(rrotsgrid_m.begin(), rrotsgrid_m.end(), sphere.begin());
} else {
//copy sphere to the radomized grid
std::copy(sphere.begin(), sphere.end(), rrotsgrid_m.begin());
}
}
bool cloud_cb(data_collection::process_cloud::Request &req,
data_collection::process_cloud::Response &res)
{
//Segment from cloud:
//May need to tweak segmentation parameters to get just the cluster I'm looking for.
std::vector<pcl::PointCloud<pcl::PointXYZ>::Ptr> clouds;
nrg_object_recognition::segmentation seg_srv;
seg_srv.request.scene = req.in_cloud;
seg_srv.request.min_x = -.75, seg_srv.request.max_x = .4;
seg_srv.request.min_y = -5, seg_srv.request.max_y = .5;
seg_srv.request.min_z = 0.0, seg_srv.request.max_z = 1.15;
seg_client.call(seg_srv);
//SegmentCloud(req.in_cloud, clouds);
//For parameter tweaking, may be good to write all cluseters to file here for examination in pcd viewer.
pcl::PointCloud<pcl::PointXYZ>::Ptr cluster (new pcl::PointCloud<pcl::PointXYZ>);
//cluster = clouds.at(0);
pcl::fromROSMsg(seg_srv.response.clusters.at(0), *cluster);
//std::cout << "found " << clouds.size() << " clusters.\n";
std::cout << "cluster has " << cluster->height*cluster->width << " points.\n";
//Write raw pcd file (objecName_angle.pcd)
std::stringstream fileName_ss;
fileName_ss << "data/" << req.objectName << "_" << req.angle << ".pcd";
std::cout << "writing raw cloud to file...\n";
std::cout << fileName_ss.str() << std::endl;
pcl::io::savePCDFile(fileName_ss.str(), *cluster);
std::cout << "done.\n";
//Write vfh feature to file:
pcl::VFHEstimation<pcl::PointXYZ, pcl::Normal, pcl::VFHSignature308> vfh;
vfh.setInputCloud (cluster);
//Estimate normals:
pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> ne;
ne.setInputCloud (cluster);
pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ> ());
ne.setSearchMethod (tree);
pcl::PointCloud<pcl::Normal>::Ptr cloud_normals (new pcl::PointCloud<pcl::Normal>);
ne.setRadiusSearch (0.03);
ne.compute (*cloud_normals);
vfh.setInputNormals (cloud_normals);
//Estimate vfh:
vfh.setSearchMethod (tree);
pcl::PointCloud<pcl::VFHSignature308>::Ptr vfhs (new pcl::PointCloud<pcl::VFHSignature308> ());
// Compute the feature
vfh.compute (*vfhs);
//Write to file: (objectName_angle_vfh.pcd)
fileName_ss.str("");
std::cout << "writing vfh descriptor to file...\n";
fileName_ss << "data/" << req.objectName << "_" << req.angle << "_vfh.pcd";
pcl::io::savePCDFile(fileName_ss.str(), *vfhs);
std::cout << "done.\n";
//Extract cph
std::vector<float> feature;
CPHEstimation cph(5,72);
cph.setInputCloud(cluster);
cph.compute(feature);
//Write cph to file. (objectName_angle.csv)
std::ofstream outFile;
fileName_ss.str("");
fileName_ss << "data/" << req.objectName << "_" << req.angle << ".csv";
outFile.open(fileName_ss.str().c_str());
std::cout << "writing cph descriptor to file...\n";
for(unsigned int j=0; j<feature.size(); j++){
outFile << feature.at(j) << " ";
}
outFile.close();
fileName_ss.str("");
std::cout << "done.\n";
res.result = 1;
}
void *
cx_group_delay(void *data, short int type, int length, int *newlength, short int *newtype, struct plot *pl, struct plot *newpl, int grouping)
{
complex *cc = (complex *) data;
double *v_phase = alloc_d(length);
double *datos,adjust_final;
double *group_delay = alloc_d(length);
int i;
/* char *datos_aux; */
/* Check to see if we have the frequency vector for the derivative */
if (!eq(pl->pl_scale->v_name, "frequency"))
{
fprintf(cp_err, "Internal error: cx_group_delay: need frequency based complex vector.\n");
return (NULL);
}
if (type == VF_COMPLEX)
for (i = 0; i < length; i++)
{
v_phase[i] = radtodeg(cph(&cc[i]));
}
else
{
fprintf(cp_err, "Signal must be complex to calculate group delay\n");
return (NULL);
}
type = VF_REAL;
/* datos_aux = (char *)cx_deriv((char *)v_phase, type, length, newlength, newtype, pl, newpl, grouping);
* datos = (double *) datos_aux;
*/
datos = (double *)cx_deriv((char *)v_phase, type, length, newlength, newtype, pl, newpl, grouping);
/* With this global variable I will change how to obtain the group delay because
* it is defined as:
*
* gd()=-dphase[rad]/dw[rad/s]
*
* if you have degrees in phase and frequency in Hz, must be taken into account
*
* gd()=-dphase[deg]/df[Hz]/360
* gd()=-dphase[rad]/df[Hz]/(2*pi)
*/
if(cx_degrees)
{
adjust_final=1.0/360;
}
else
{
adjust_final=1.0/(2*M_PI);
}
for (i = 0; i < length; i++)
{
group_delay[i] = -datos[i]*adjust_final;
}
/* Adjust to Real because the result is Real */
*newtype = VF_REAL;
/* Set the type of Vector to "Time" because the speed of group units' s'
* The different types of vectors are INCLUDE \ Fte_cons.h
*/
pl->pl_dvecs->v_type= SV_TIME;
return ((char *) group_delay);
}