Esempio n. 1
0
int main(int argc,char *argv[])
{
  CkPrintf("init called\n");
  CrnInitStream(&rs,0,0);
  int facesA[nFaces*nPer],facesB[nFaces*nPer];
  const int nPoints=aPoints+bPoints;
  CkVector3d pts[nPoints];
  FEM_Print("Fabricating points:");
  CkVector3d a2bLocs(randVec(CkVector3d(10.0,90.0,50.0)));
  print("true offset vector "); print(a2bLocs,15); 
  int i;
  //Fabricate some test points (just purely random)
  for (i=0;i<aPoints;i++) {
    pts[i]=randVec(CkVector3d(5.0,5.0,5.0));
    pts[i+a2bPoints]=pts[i]+a2bLocs;
  }
  makeFaces(facesA,facesB);
  
  //Actually do the match:
  //verbosematchingDest dest;
  unionFind uf(nPoints); unionFindDest dest(uf);
  FEM_Print("Finding offset");
  linearOffsetMatcher matcher(nFaces,nPer,facesA,facesB,0, nPoints,pts);
  FEM_Print("Beginning match");
  matcher.match(dest);
  FEM_Print("Compressing paths");
  uf.compress();
  FEM_Print("Testing union");
  testUnion(nPoints,uf.detach());
  FEM_Print("Done");
}
Esempio n. 2
0
void CkQuadView::pup(PUP::er &p) {
	CkView::pup(p);
	p.comment("Texture corners");
	p|nCorners;
	for (int i=0;i<nCorners;i++) {
		p|corners[i];
		p|texCoord[i];
	}
	
// Pup the image:
	x_tex.pup(p);

#ifdef CMK_LIVEVIZ3D_CLIENT
	if (p.isUnpacking()) { /* immediately upload image to OpenGL */
		CkAllocImage *img=x_tex.getImage();
		oglTextureFormat_t fmt=oglImageFormat(*img);
		c_tex=new oglLilTex(img->getData(),x_tex.gl_w,x_tex.gl_h,
			fmt.format,fmt.type);
		stats::get()->add(x_tex.w*x_tex.h,op_upload_pixels);
		stats::get()->add(x_tex.gl_w*x_tex.gl_h,op_uploadpad_pixels);
		/// Scale texture coordinates from the partial image to OpenGL fractions:
		double tx=x_tex.w/(double)x_tex.gl_w;
		double ty=x_tex.h/(double)x_tex.gl_h;
		for (int i=0;i<nCorners;i++) 
			texCoord[i]=c_tex->texCoord(
				CkVector3d(tx*texCoord[i].x,ty*texCoord[i].y,texCoord[i].z)
			);
		
		//Now that we've copied the view into GL, 
		// flush the old in-memory copy:
		delete img;
	}
#endif

}
Esempio n. 3
0
  main(CkArgMsg* m)
  {
    nElements=5;
    if(m->argc > 1) nElements = atoi(m->argv[1]);
    delete m;
    CkPrintf("Running Hello on %d processors for %d elements\n",
	     CkNumPes(),nElements);
    mid = thishandle;
    
    CollideGrid3d gridMap(CkVector3d(0,0,0),CkVector3d(2,100,2));
    CollideHandle collide=CollideCreate(gridMap,
    	CollideSerialClient(printCollisionHandler,0));
    
    arr = CProxy_Hello::ckNew(collide,nElements);
    
    arr.DoIt();
  };
Esempio n. 4
0
//Set our points as the 8 corners of this bounding box:
CkInterestSet::CkInterestSet(const CkBbox3d &box) 
	:nInterest(8)
{
	for (int i=0;i<8;i++) {
		loc[i]=CkVector3d(
			(i&1)?box.max.x:box.min.x,
			(i&2)?box.max.y:box.min.y,
			(i&4)?box.max.z:box.min.z
		);
	}
}
Esempio n. 5
0
/// Get our i'th clipping plane.
CkHalfspace3d CkViewpoint::getClip(int i) const
{
	double target=0, dir=1;
	int r=0; // matrix row
	switch (i) {
	case 0: break;
	case 1: target=-wid; dir=-1; break;
	case 2: r=1; break;
	case 3: target=-ht; dir=-1; r=1; break;
	}
	// Require:  dir * proj(v) >= target
	//  where proj(x)=(v dot m(r) + m(r,3))/(v dot m(3) + m(3,3))
	//  so  (assuming w positive)
	//      dir * (v dot m(r) + m(r,3)) >= target * (v dot m(3) + m(3,3))
	//  which we cast as (v dot h.n) + h.d >= 0
	CkHalfspace3d h;
	h.n=  dir*CkVector3d(m(r,0),m(r,1),m(r,2))
	  -target*CkVector3d(m(3,0),m(3,1),m(3,2));
	h.d=  dir*m(r,3) - target*m(3,3);
	return h;
}
Esempio n. 6
0
/**
 * Create a new CkInterestView for this (novel) viewpoint.
 * Default implementation creates a flat-on viewpoint and 
 * calls render() to create a new texture.
 */
bool CkInterestViewable::newViewpoint(const CkViewpoint &univ2screen,CkViewpoint &univ2texture) 
{
//Find our destination rectangle onscreen, to estimate our resolution needs:
	CkRect r; r.empty();
	CkRect clipR; clipR.empty();
	for (int i=0;i<interest.size();i++) { //Screen-project this interest point
		CkVector3d s(univ2screen.project(interest[i]));
		if (!(s.z>0)) continue; // Just ignore behind-the-viewer points
		// return false;
		r.add((int)s.x,(int)s.y);
		univ2screen.clip(s);
		clipR.add((int)s.x,(int)s.y);
	}
	if (clipR.area()<2) return false;
	
	if (r.l==r.r) r.r++; /* enlarge vertical sliver */
	if (r.t==r.b) r.b++; /* enlarge horizontal sliver */

//Round up the texture size based on the onscreen size
//   (Note: OpenGL textures *MUST* be a power of two in both directions)
//   ( for mipmapping, the textures must also be square )
	double inset=2; //Pixels to expand output region by (to ensure a clean border)
	
	 int target_w=(int)(r.wid()+2*inset), target_h=(int)(r.ht()+2*inset);
#if 0 /* for OpenGL: power-of-two textures */
	const int start_sz=4, max_sz=512;
	int wid=start_sz, ht =start_sz;  // Proposed size
	// Scale up size until both width and height are acceptable.
	while ((wid<target_w) || (ht<target_h)) {
		ht*=2; wid*=2;
	}
#else /* non-power-of-two textures (sensible default) */
	int max_sz=512;
	int wid=target_w, ht=target_h;
#endif
	
//Create our new view in the plane of our center, 
//  using a perspective-scaled version of the old axes:
	const CkVector3d &E=univ2screen.getEye();
	double eyeCenter=(center-E).mag();
	double eyeViewplane=(univ2screen.projectViewplane(center)-E).mag();
	double perspectiveScale=eyeCenter/(1.0e-10+eyeViewplane);
	// printf("PerspectiveScale=%f\n",perspectiveScale);
	
	// New axes are just scaled versions of old axes:
	double Xscale=perspectiveScale;//*r.wid()/(wid-2*inset);
	double Yscale=perspectiveScale;//*r.ht()/(ht-2*inset);
	
	// If the resulting texture is too big, scale it down:
	if (wid>max_sz) { wid=max_sz; Xscale*=r.wid()/(wid-2*inset); }
	if (ht>max_sz) { ht=max_sz; Yscale*=r.ht()/(ht-2*inset); }
	
	/*
	if (Xscale ==0 || Yscale==0) 
		CmiAbort("liveViz3d> Illegal axis scaling");
	*/
	
	CkVector3d X=univ2screen.getX()*Xscale;
	CkVector3d Y=univ2screen.getY()*Yscale;
	// New origin is just shifted version of old origin:
	CkVector3d R=perspectiveScale*(univ2screen.viewplane(CkVector3d(r.l,r.t,0))-E)+E
		-inset*X-inset*Y;
	univ2texture=CkViewpoint(E,R,X,Y,wid,ht);
	
	if (1) {
	/// Set priority:
	// const static double distCutoff=10.0;
	priorityAdjust=(int)(
		std::max(wid,ht)*(1.0/1.0) /* area boost */
		// +1.0/std::max(eyeCenter,distCutoff)*(50.0/distCutoff) /* nearness boost */
		// +(r==clipR)*20.0 /* fully onscreen boost */
	);
	}
	
	return true;
}
Esempio n. 7
0
/// Initialize this view, from this viewpoint:
CkInterestView::CkInterestView(int wid,int ht,int n_colors,
	const CkInterestSet &univ_,
	const CkViewpoint &univ2texture)
	:CkQuadView(wid,ht,n_colors), univ(univ_)
{
	nCorners=4;
	corners[0]=univ2texture.viewplane(CkVector3d(0  , 0, 0));
	corners[1]=univ2texture.viewplane(CkVector3d(wid, 0, 0));
	corners[2]=univ2texture.viewplane(CkVector3d(wid,ht, 0));
	corners[3]=univ2texture.viewplane(CkVector3d(0  ,ht, 0));
	int cx=wid/2, cy=ht/2;
	projC=univ2texture.viewplane(CkVector3d(cx  ,cy  , 0));
	projX=univ2texture.viewplane(CkVector3d(cx+1,cy  , 0));
	projY=univ2texture.viewplane(CkVector3d(cx  ,cy+1, 0));
	texCoord[0]=CkVector3d(0,0,0);
	texCoord[1]=CkVector3d(1,0,0);
	texCoord[2]=CkVector3d(1,1,0);
	texCoord[3]=CkVector3d(0,1,0);
	
	proj.setPoints(univ.size());
	for (int i=0;i<univ.size();i++) 
	{ //Back-project my interest points into the texture plane:
		proj[i]=univ2texture.projectViewplane(univ[i]);
	}
}
Esempio n. 8
0
CkVector3d randVec(const CkVector3d &scale) {
	return CkVector3d(randVal(scale.x),randVal(scale.y),randVal(scale.z));
}