TreeNode* flat(TreeNode *node) {

        if (node == nullptr) {
            return node;
        }

        if (node->left == nullptr && node->right == nullptr) {
            return node;
        }

        TreeNode *left = flat(node->left);

        if (left == nullptr) {
            node -> right = flat(node->right);
        }
        else {
            TreeNode *temp = left;
            while (temp->right != nullptr) {
                temp = temp->right;
            }
            temp->right = flat(node->right);
            node->right = left;
            node->left = nullptr;
        }

        return node;
    }
Beispiel #2
0
int main()
{
   WLLC lista1 = inicjuj();
    WLLC lista2 = inicjuj();
   lista1 =  dopisz_liczbe(5,(dopisz_liczbe(3,NULL),dopisz_liste(dopisz_liczbe(5,dopisz_liczbe(8,NULL)),dopisz_liczbe(2,dopisz_liste(dopisz_liczbe(1,dopisz_liczbe(5,NULL)),dopisz_liste(NULL,NULL))))));
   lista2 = dopisz_liczbe(3,dopisz_liczbe(2,dopisz_liczbe(1,NULL)));
   printf("Lista 1:\n");
   wypisz(lista1);
   printf("\n\nLista 2:\n");
   wypisz(lista2);
   WLLC lista3 = merge(lista1,lista2);
   printf("\n\nLista 3:\n");
   wypisz(lista3);
   printf("\n\nLista 1 (po mergu):\n");
   wypisz(lista1);
   WLLC lista4 = flat(lista3);
   printf("\n\nLista 4 (flat z listy 3):\n");
   wypisz(lista4);
   WLLC lista5 = inicjuj();
   lista5 = dopisz_liczbe(2,dopisz_liste(dopisz_liste(dopisz_liczbe(3,dopisz_liczbe(4,NULL)),NULL),NULL));
   printf("\n\nLista 5 bez flat:\n");
   wypisz(lista5);
   printf("\n\nLista 5 z flat:\n");
   wypisz(flat(lista5));
   putchar('\n');
    return 0;
}
Beispiel #3
0
//takes a non-atomic list and returns a list which is the original list with the parenthesis removed..except the outer parenthesis
list flat(list p)
{
    if(is_null(p))
        return null();
    if(atom(p))
        return cons( p, null());
    return append(flat(car(p)),flat(cdr(p)));
}
FRAGMENT(JSString, subclasses) {
  js::Rooted<JSFlatString *> flat(cx, JS_FlattenString(cx, JS_NewStringCopyZ(cx, "Hi!")));

  breakpoint();

  (void) flat;
}
void EvtPropSLPole::decay( EvtParticle *p ){

  if(! _isProbMaxSet){

     EvtId parnum,mesnum,lnum,nunum;

     parnum = getParentId();
     mesnum = getDaug(0);
     lnum = getDaug(1);
     nunum = getDaug(2);

     double mymaxprob = calcMaxProb(parnum,mesnum,
                           lnum,nunum,SLPoleffmodel);

     setProbMax(mymaxprob);

     _isProbMaxSet = true;

  }

  double minKstMass = EvtPDL::getMinMass(p->getDaug(0)->getId());
  double maxKstMass = EvtPDL::getMaxMass(p->getDaug(0)->getId());

  EvtIntervalFlatPdf flat(minKstMass, maxKstMass);
  EvtPdfGen<EvtPoint1D> gen(flat);
  EvtPoint1D point = gen(); 
 
  double massKst = point.value();

  p->getDaug(0)->setMass(massKst);
  p->initializePhaseSpace(getNDaug(),getDaugs());

//  EvtVector4R p4meson = p->getDaug(0)->getP4();

  calcamp->CalcAmp(p,_amp2,SLPoleffmodel); 

  EvtParticle *mesonPart = p->getDaug(0);
  
  double meson_BWAmp = calBreitWigner(mesonPart, point);  

  int list[2];
  list[0]=0; list[1]=0;
  _amp2.vertex(0,0,_amp2.getAmp(list)*meson_BWAmp);
  list[0]=0; list[1]=1;
  _amp2.vertex(0,1,_amp2.getAmp(list)*meson_BWAmp);

  list[0]=1; list[1]=0;
  _amp2.vertex(1,0,_amp2.getAmp(list)*meson_BWAmp);
  list[0]=1; list[1]=1;
  _amp2.vertex(1,1,_amp2.getAmp(list)*meson_BWAmp);

  list[0]=2; list[1]=0;
  _amp2.vertex(2,0,_amp2.getAmp(list)*meson_BWAmp);
  list[0]=2; list[1]=1;
  _amp2.vertex(2,1,_amp2.getAmp(list)*meson_BWAmp);
     
  
  return;

}
Beispiel #6
0
void main()
{
char special;
special=choice_system();
if(special=='1')
hostel();
else
if(special=='2')
flat();
else
if(special=='3')
{
     clrscr();
     gotoxy(23,12);
     printf("Thank you for using this program");
     gotoxy(23,13);
     printf("Coded by: Shivam");
     gotoxy(33,14);
     printf("Akshay");
     gotoxy(33,15);
     printf("Aayush");
     getch();	 
}
else
main();
}
Beispiel #7
0
FRAGMENT(JSString, subclasses) {
  JS::Rooted<JSFlatString*> flat(
      cx, JS_FlattenString(cx, JS_NewStringCopyZ(cx, "Hi!")));

  breakpoint();

  use(flat);
}
Beispiel #8
0
static void sample(Point* p, Point* q)
{
 Point rr, *r=&rr;
 double t = 0.45 + 0.1 * (rand()/(double) RAND_MAX);
 T(r) = T(p) + t*(T(q)-T(p));
 gamma(r);
 if (flat(p,q,r)) line(p,q); else { sample(p,r); sample(r,q); }
}
Beispiel #9
0
void contractForm::fillFlats()
{
    if(cmbFlat->count()>0) cmbFlat->clear();
    QMapIterator<int,QString> flat(db->getFlatsName());
    while(flat.hasNext()){
        flat.next();
        cmbFlat->addItem(flat.value(),flat.key());
    }
}
Beispiel #10
0
void DBlockHeader::load(std::istream &stream, size_t blockid)
{
    mUnknown1 = VFS::read_le32(stream);
    mWidth = VFS::read_le32(stream);
    mHeight = VFS::read_le32(stream);
    mObjectRootOffset = VFS::read_le32(stream);
    mUnknown2 = VFS::read_le32(stream);
    stream.read(mModelData[0].data(), sizeof(mModelData));
    for(uint32_t &val : mUnknown3)
        val = VFS::read_le32(stream);

    stream.seekg(mObjectRootOffset);

    std::vector<int32_t> rootoffsets(mWidth*mHeight);
    for(int32_t &val : rootoffsets)
        val = VFS::read_le32(stream);

    for(int32_t offset : rootoffsets)
    {
        while(offset > 0)
        {
            stream.seekg(offset);
            int32_t next = VFS::read_le32(stream);
            /*int32_t prev =*/ VFS::read_le32(stream);

            int32_t x = VFS::read_le32(stream);
            int32_t y = VFS::read_le32(stream);
            int32_t z = VFS::read_le32(stream);
            uint8_t type = stream.get();
            uint32_t objoffset = VFS::read_le32(stream);

            if(type == ObjectType_Model)
            {
                stream.seekg(objoffset);
                ref_ptr<ModelObject> mdl(new ModelObject(blockid|offset, x, y, z));
                mdl->load(stream, mModelData);

                mObjects.insert(blockid|offset, mdl);
            }
            else if(type == ObjectType_Flat)
            {
                stream.seekg(objoffset);
                ref_ptr<FlatObject> flat(new FlatObject(blockid|offset, x, y, z));
                flat->load(stream);

                mObjects.insert(blockid|offset, flat);
            }

            offset = next;
        }
    }

    for(ref_ptr<ObjectBase> &obj : mObjects)
        obj->loadAction(stream, *this);
}
ImagePtr	FlatFrameFactory::operator()(const ImageSequence& images,
			const ImagePtr darkimage) const {
	Image<double>	*doubledark = dynamic_cast<Image<double>*>(&*darkimage);
	Image<float>	*floatdark = dynamic_cast<Image<float>*>(&*darkimage);
	if (doubledark) {
		debug(LOG_DEBUG, DEBUG_LOG, 0, "dark is Image<double>");
		CountNaNs<double, double>	countnans;
		debug(LOG_DEBUG, DEBUG_LOG, 0, "dark has %f nans",
			countnans(*doubledark));
		return flat(images, *doubledark);
	}
	if (floatdark) {
		debug(LOG_DEBUG, DEBUG_LOG, 0, "dark is Image<float>");
		CountNaNs<float, double>	countnans;
		debug(LOG_DEBUG, DEBUG_LOG, 0, "dark has %f nans",
			countnans(*floatdark));
		return flat(images, *floatdark);
	}
	throw std::runtime_error("unknown dark image type");
}
// flat predicate to determine when we subdivide
bool AdaptiveWaterline::flat( Fiber& start, Fiber& mid, Fiber& stop ) const {
    if ( start.size() != stop.size() ) // start, mid, and stop need to have same size()
        return false;
    else if ( start.size() != mid.size() )
        return false;
    else if ( mid.size() != stop.size() )
        return false;
    else {
        if (!start.empty() ) { // all now have same size
            assert( start.size() == stop.size() && start.size() == mid.size() );
            for (unsigned int n=0;n<start.size();++n) {
                // now check for angles between cl-points (NOTE: cl-points might not belong to same loop?)
                // however, errors here only lead to dense sampling which is harmless (but slow)
                if ( (!flat( start.upperCLPoint(n) , mid.upperCLPoint(n) , stop.upperCLPoint(n) )) )
                    return false;
                else if (!flat( start.lowerCLPoint(n) , mid.lowerCLPoint(n) , stop.lowerCLPoint(n) )) 
                    return false;
            }
        }
        return true;
    } 
}
Beispiel #13
0
//возвращает 0, если pt вне пирамиды с вершиной в начале координат и основанием tr, 1 - внутри
bool InsidePiramide(Triangle& tr,vec3 pt)
{
	vec3 cr;
	if(!flat_cross_line2(flat(tr.v[0],tr.norm), pt, &cr))
		return 0;

	for(int i=0;i<3;i++)
	{
		vec3 tmpv = pt - tr.v[i], vv = tr.v[(i+1)%3] - tr.v[i];
		vec3 nn1 = vec3::vect_mult(vv,tr.norm);
		if(vec3::dot(nn1,tmpv)<0) return 0;
	}
	return 1;
}
Eigen::VectorXd flattenSymmetric(Eigen::MatrixXd symm)
{
  //todo: other data types?
  //todo: safety/square matrix checking?
  int num_entries = symm.rows() * (symm.rows() + 1) / 2;
  Eigen::VectorXd flat(num_entries);
  int count = 0;
  for (int i = 0; i < symm.cols(); i++) {
    int ltcsz = symm.cols() - i;
    flat.block(count, 0, ltcsz, 1) = symm.block(i, i, ltcsz, 1);
    count += ltcsz;
  }
  return flat;
}
    TreeNode *flat(TreeNode *node)
    {
        if(node == NULL)
            return NULL;

        TreeNode *l = flat(node->left);

        TreeNode *r = flat(node->right);

        node->left = NULL;

        TreeNode *tmp = node;
        tmp->left = NULL;
        
        tmp->right = l;
        while (tmp->right)
        {
            tmp = tmp->right;
        }

        tmp->right = r;
        
        return node;
    }
void AdaptivePathDropCutter::adaptive_sample(const Span* span, double start_t, double stop_t, CLPoint start_cl, CLPoint stop_cl) {
    const double mid_t = start_t + (stop_t-start_t)/2.0; // mid point sample
    assert( mid_t > start_t );  assert( mid_t < stop_t );
    CLPoint mid_cl = span->getPoint(mid_t);
    //std::cout << " apdc sampling at " << mid_t << "\n";
    subOp[0]->run( mid_cl );
    double fw_step = (stop_cl-start_cl).xyNorm();
    if ( (fw_step > sampling) || // above minimum step-forward, need to sample more
          ( (!flat(start_cl,mid_cl,stop_cl)) && (fw_step > min_sampling) ) ) { // OR not flat, and not max sampling
        adaptive_sample( span, start_t, mid_t , start_cl, mid_cl  );
        adaptive_sample( span, mid_t  , stop_t, mid_cl  , stop_cl );
    } else {
        clpoints.push_back(stop_cl); 
    }
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QVector<double> DynamicTableData::flattenData() const
{
  int numRows = getNumRows();
  int numCols = getNumCols();

  QVector<double> flat(numRows * numCols);
  for (int row = 0; row < numRows; row++)
  {
    for (int col = 0; col < numCols; col++)
    {
      flat[row * numCols + col] = m_TableData[row][col];
    }
  }

  return flat;
}
Beispiel #18
0
/// Generate the winning lines from 4 prototypes.
/// We only need the prototypes and the isomorphisms to generate all 76
/// of the winning lines.  Note that iso::add() removes duplicates,
/// so we can afford to be overzealous in generating them.
void
win::init() {
	win main(0,21,42,63);			// a major diagonal
	win flat(0,1,2,3);				// flat, but cuts 2 major diagonals
	win body(16,17,18,19);			// flat without cutting a major diagonal
	win diag(0,5,10,15);			// "minor" diagonal.  All cut 2 majors.

	nextwin = 0;

	for (int i=0; i<iso::nextiso; i++) {
		win::add(iso::isos[i] * main);
		win::add(iso::isos[i] * flat);
		win::add(iso::isos[i] * diag);
		win::add(iso::isos[i] * body);
	}
#ifndef NDEBUG
	cout << "There are " << nextwin << " winning lines" << endl;
#endif
}
Beispiel #19
0
int main(int argc, char * argv[])
{
    std::cout<<"Common LAAS Raster library"<<std::endl;
    if (argc < 3) {
        std::cerr<<"usage: "<<argv[0]<<" flat.tiff obstacle.tiff region_out.tif"<<std::endl;
        return EXIT_FAILURE;
    }

    gladys::gdal flat(argv[1]);
    gladys::gdal obstacle(argv[2]);
    gladys::gdal region;
    region.copy_meta(flat, clara::region::N_RASTER);
    region.bands_name = {"NO_3D_CLASS", "FLAT", "OBSTACLE", "ROUGH", "SLOPE"};
    region.bands[clara::region::FLAT] = flat.bands[0];
    region.bands[clara::region::OBSTACLE] = obstacle.bands[0];

    region.save(argv[3]);

    return EXIT_SUCCESS;
}
void AdaptiveWaterline::yfiber_adaptive_sample(const Span* span, double start_t, double stop_t, Fiber start_f, Fiber stop_f) {
    const double mid_t = start_t + (stop_t-start_t)/2.0; // mid point sample
    assert( mid_t > start_t );  assert( mid_t < stop_t );
    //std::cout << "yfiber sample= ( " << start_t << " , " << stop_t << " ) \n";
    Point mid_p1 = Point( span->getPoint( mid_t ).x, miny,  zh );
    Point mid_p2 = Point( span->getPoint( mid_t ).x, maxy, zh );
    Fiber mid_f = Fiber( mid_p1, mid_p2 );
    subOp[1]->run( mid_f );
    double fw_step = fabs( start_f.p1.x - stop_f.p1.x ) ;
    if ( fw_step > sampling ) { // above minimum step-forward, need to sample more
        yfiber_adaptive_sample( span, start_t, mid_t , start_f, mid_f  );
        yfiber_adaptive_sample( span, mid_t  , stop_t, mid_f  , stop_f );
    } else if ( !flat(start_f,mid_f,stop_f)   ) {
        if (fw_step > min_sampling) { // not a flat segment, and we have not reached maximum sampling
            yfiber_adaptive_sample( span, start_t, mid_t , start_f, mid_f  );
            yfiber_adaptive_sample( span, mid_t  , stop_t, mid_f  , stop_f );
        }
    } else {
        yfibers.push_back(stop_f); 
    }
}
 void PointCloudModelGenerator::generate(
   const std::string& model_name,
   pcl::PointCloud<PointT>& output,
   double hole_rate)
 {
   output.points.clear();
   if (model_name == "flat") {
     flat(output, hole_rate);
   }
   else if (model_name == "stairs") {
     stairs(output, hole_rate);
   }
   else if (model_name == "hills") {
     hills(output, hole_rate);
   }
   else if (model_name == "gaussian") {
     gaussian(output, hole_rate);
   }
   else if (model_name == "flat_pole") {
     flatPole(output, hole_rate);
   }
 }
Beispiel #22
0
/*
 * roomin:
 *	Find what room some coordinates are in. NULL means they aren't
 *	in any room.
 */
struct room *
roomin(const coord *cp)
{
    struct room *rp;
    int *fp;

    fp = &flat(cp->y, cp->x);
    if (*fp & F_PASS)
	return &passages[*fp & F_PNUM];

    for (rp = rooms; rp < &rooms[MAXROOMS]; rp++)
	if (cp->x <= rp->r_pos.x + rp->r_max.x && rp->r_pos.x <= cp->x
	 && cp->y <= rp->r_pos.y + rp->r_max.y && rp->r_pos.y <= cp->y)
	    return rp;

    msg("in some bizarre place (%d, %d)", unc(*cp));
#ifdef MASTER
    abort();
    return NULL;
#else
    return NULL;
#endif
}
void BezierCurveEvaluator::addBezier(std::vector<Point>& evaluatePoints, Point points[], float leftBorder, float rightBorder) const
{
	//Ensure function
	rightBorder = MIN(rightBorder, points[3].x);
	leftBorder = MIN(leftBorder, points[0].x);
	if(flat(points)) {
		for(int i=0; i<4; i++) {
			if(points[0].x < leftBorder && points[i - 1].x < leftBorder && points[i].x >= leftBorder) {
				//Interpolate
				float dx = points[i].x - points[i - 1].x;
				float q = points[i].x - leftBorder;
				Point p;
				p.x = leftBorder;
				p.y = q / dx * points[i - 1].y  - (1 - q / dx) * points[i].y;
				evaluatePoints.push_back(p);
			}
			if(points[3].x > rightBorder && points[i + 1].x > rightBorder && points[i].x <= rightBorder) {
				//Interpolate
				float dx = points[i + 1].x - points[i].x;
				float q = rightBorder - points[i].x;
				Point p;
				p.x = rightBorder;
				p.y = q / dx * points[i + 1].y + (1 - q / dx) * points[i].y;
				evaluatePoints.push_back(p);
			}
			if(points[i].x >= leftBorder && points[i].x <= rightBorder) {
				evaluatePoints.push_back(points[i]);
			}
		}
	} else {
		Point left[4], right[4];
		divide(points, left, right);
		addBezier(evaluatePoints, left, leftBorder, rightBorder);
		addBezier(evaluatePoints, right, leftBorder, rightBorder);
	}
}
Beispiel #24
0
/*
 * cansee:
 *	Returns true if the hero can see a certain coordinate.
 */
int
cansee(int y, int x)
{
    struct room *rer;
    coord tp;

    if (on(player, ISBLIND))
	return FALSE;
    if (dist(y, x, hero.y, hero.x) < LAMPDIST)
    {
	if (flat(y, x) & F_PASS)
	    if (y != hero.y && x != hero.x &&
		!step_ok(chat(y, hero.x)) && !step_ok(chat(hero.y, x)))
		    return FALSE;
	return TRUE;
    }
    /*
     * We can only see if the hero in the same room as
     * the coordinate and the room is lit or if it is close.
     */
    tp.y = y;
    tp.x = x;
    return ((rer = roomin(&tp)) == proom && !(rer->r_flags & ISDARK));
}
Beispiel #25
0
void test_forwardVelKin() {

	const int MAXNS = NUMSTATE(WmrModel::MAXNF);
	const int MAXNV = NUMQVEL(WmrModel::MAXNF);

	//make WmrModel object
	WmrModel mdl;
	Real state[MAXNS];
	
	zoe(mdl,state,0);
	//rocky(mdl,state,0);
	//talon(mdl,state,0); //TODO

	//get from WmrModel
	const int nw = mdl.get_nw();
	const int nt = mdl.get_nt();
	const int na = mdl.get_na();
	const int nv = NUMQVEL(mdl.get_nf());

	//terrain
	SurfaceVector surfs;

	flat(surfs);
	//ramp(surfs);
	//grid(surfs, ResourceDir() + std::string("gridsurfdata.txt") );

	//init contact geometry
	WheelContactGeom wcontacts[WmrModel::MAXNW];
	TrackContactGeom tcontacts[WmrModel::MAXNW];
	ContactGeom* contacts = 0;

	if (nw > 0) {
		contacts = static_cast<ContactGeom*>(wcontacts);
	} else if (nt > 0) {
		sub_initTrackContactGeom(mdl, tcontacts);
		contacts = static_cast<ContactGeom*>(tcontacts);
	}

	//convert state to homogeneous transforms
	HomogeneousTransform HT_parent[WmrModel::MAXNF];
	HomogeneousTransform HT_world[WmrModel::MAXNF];
	stateToHT(mdl,state,HT_parent,HT_world);

	//update contact geometry
	updateModelContactGeom(mdl, surfs, HT_world, mdl.min_npic, contacts);

	//controller inputs
	Real u[WmrModel::MAXNA];
	Real qvel_cmd[MAXNV];
	Real time = 0;

	mdl.controller(mdl, 0, state, u, qvel_cmd);

	//allocate outputs
	Real qvel[MAXNV];
	Vec3 vc[WmrModel::MAXNW];

	//compute joint space velocity
	forwardVelKin(mdl, state, u, HT_world, contacts, qvel, vc);
	
	//PRINT
	std::cout << "u =\n";
	printMatReal(na,1,u,-1,-1);
	std::cout << std::endl;

	std::cout << "qvel_cmd =\n";
	printMatReal(nv,1,qvel_cmd,-1,-1);
	std::cout << std::endl;

	std::cout << "qvel =\n";
	printMatReal(nv,1,qvel,-1,-1);
	std::cout << std::endl;

	std::cout << "vc =\n";
	printnVec3(nw,vc,-1,-1);
	std::cout << std::endl;

	if (1) {
		//time it
		int n= (int) 1e5;
		timeval t0, t1;

		gettimeofday(&t0, NULL);
		for (int i=0; i<n; i++) {
			forwardVelKin(mdl, state, u, HT_world, contacts, qvel, 0);
		}
		gettimeofday(&t1, NULL);
		std::cout << "wheelJacobians()\n";
		std::cout << "iterations: " << (Real) n << std::endl;
		std::cout << "clock (sec): " << tosec(t1)-tosec(t0) << std::endl;
	}
	

}
Beispiel #26
0
int main(int argc, char *argv[])
{
	QApplication app(argc, argv);
	QWidget container;
	container.resize(640, 680);
	container.setFocusPolicy ( Qt::NoFocus );
	Engine engine(NULL);

	QMenuBar open_menu_bar(&container);
	QMenu open_menu("&File", &container);

	QAction open("&Open", &container);
	open.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_O));
	open_menu.addAction(&open);

	QAction reset("&Reset", &container);
	reset.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_R));
	open_menu.addAction(&reset);

	QAction save("&Save", &container);
	save.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_S));
	open_menu.addAction(&save);

	QAction close("&Close", &container);
	close.setShortcut(QKeySequence(Qt::ALT + Qt::Key_F4));
	open_menu.addAction(&close);

	QMenu draw_menu("&Drawmodes", &container);

	QAction points("&Points", &container);
	points.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_P));
	draw_menu.addAction(&points);

	QAction wire("&Wireframe", &container);
	wire.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_W));
	draw_menu.addAction(&wire);

	QAction flat("&Flat shaded", &container);
	flat.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_F));
	draw_menu.addAction(&flat);

	QAction smooth("&Smooth shaded", &container);
	smooth.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
	draw_menu.addAction(&smooth);

	/**** MENU CONVEX HULL ****/
	QMenu convex_hull("Convex Hull", &container);

	QAction calc("&Calculate CH", &container);
	calc.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_C));
	convex_hull.addAction(&calc);

	/**** MENU HELP ****/
	QMenu help_menu("&?", &container);

	QAction help("&Help", &container);
	help.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_H));
	help_menu.addAction(&help);

	QAction about("&About", &container);
	about.setShortcut(QKeySequence(Qt::CTRL + Qt::Key_A));
	help_menu.addAction(&about);
	
	open_menu_bar.addMenu(&open_menu);
	open_menu_bar.addMenu(&draw_menu);
	open_menu_bar.addMenu(&convex_hull);
	open_menu_bar.addMenu(&help_menu);
	
	Window_gl window(&container);
	window.setGeometry(0,22,640, 680);

	container.show();
	
	QDialog instructions( NULL );
	instructions.setFixedSize(300,180);
	instructions.setWindowTitle("Help");
	QLabel instr_text("\nUp - Sposta l'osservatore verso l'alto\nDown - Sposta l'osservatore verso il basso\nLeft - Ruota verso sinistra\nRight - Ruota verso destra\nShift+Up - Zoom In\nShift+Down - Zoom out\n\nSi ricorda che il programma e' in grado di gestire\nsolo files di tipo .OFF.\nAltri formati non sono attualmente supportati.", &instructions);
	instr_text.setTextFormat(Qt::AutoText);
	instr_text.setWordWrap(true);
	instructions.hide();

	QDialog credits( NULL );
	credits.setFixedSize(300,100);
	credits.setWindowTitle("Credits");
	QLabel cred_text("\tCGVew v.1.7\n\nA cura di Fabio Guggeri ([email protected])\ne Stefano Marras ([email protected]).\n", &credits);
	cred_text.setTextFormat(Qt::AutoText);
	cred_text.setWordWrap(true);
	credits.hide();

	QObject::connect( &open, SIGNAL(triggered()), &engine, SLOT(open_file()) );
	QObject::connect( &reset, SIGNAL(triggered()), &window, SLOT(reset()) );
	QObject::connect( &reset, SIGNAL(triggered()), &engine, SLOT(reset()) );
	QObject::connect( &save, SIGNAL(triggered()), &engine, SLOT(save_file()) );
	QObject::connect( &points, SIGNAL(triggered()), &window, SLOT(set_p_drawmode()) );
	QObject::connect( &wire, SIGNAL(triggered()), &window, SLOT(set_w_drawmode()) );
	QObject::connect( &flat, SIGNAL(triggered()), &window, SLOT(set_f_drawmode()) );
	QObject::connect( &smooth, SIGNAL(triggered()), &window, SLOT(set_s_drawmode()) );
	QObject::connect( &help, SIGNAL(triggered()), &instructions, SLOT(show()) );
	QObject::connect( &about, SIGNAL(triggered()), &credits, SLOT(show()) );
	QObject::connect( &close, SIGNAL(triggered()), &app, SLOT(quit()) );
	QObject::connect( &engine, SIGNAL(send_dcel(QVector<DCEL>&)), &window, SLOT(add_dcel(QVector<DCEL>&)) );
	QObject::connect( &calc, SIGNAL(triggered()), &engine, SLOT(calculate_ch()) );

	window.setFocus();

	return app.exec();
}
    /**
     *
     * @param parentId
     * @return
     */
    virtual int writeH5Data(hid_t parentId)
    {

      int err = 0;

      // Generate the number of neighbors array and also compute the total number
      // of elements that would be needed to flatten the array
      std::vector<int32_t> numNeighbors(_data.size());

      size_t total = 0;
      for(size_t dIdx = 0; dIdx < _data.size(); ++dIdx)
      {
        numNeighbors[dIdx] = static_cast<int32_t>(_data[dIdx]->size());
        total += _data[dIdx]->size();
      }

      // Check to see if the NumNeighbors is already written to the file
      bool rewrite = false;
      if (H5Lite::datasetExists(parentId, DREAM3D::FieldData::NumNeighbors) == false)
      {
        rewrite = true;
      }
      else
      {
        std::vector<int32_t> fileNumNeigh(_data.size());
        err = H5Lite::readVectorDataset(parentId, DREAM3D::FieldData::NumNeighbors, fileNumNeigh);
        if (err < 0)
        {
          return -602;
        }

        // Compare the 2 vectors to make sure they are exactly the same;
        if (fileNumNeigh.size() != numNeighbors.size())
        {
          rewrite = true;
        }
        // The sizes are the same, now compare each value;
        int32_t* numNeighPtr = &(numNeighbors.front());
        int32_t* fileNumNeiPtr = &(fileNumNeigh.front());
        size_t nBytes = numNeighbors.size() * sizeof(int32_t);
        if (::memcmp(numNeighPtr, fileNumNeiPtr, nBytes) != 0)
        {
          rewrite = true;
        }
      }

      // Write out the NumNeighbors Array
      if(rewrite == true)
      {
        std::vector<hsize_t> dims(1, numNeighbors.size());
        err = H5Lite::writeVectorDataset(parentId, DREAM3D::FieldData::NumNeighbors, dims, numNeighbors);
        if(err < 0)
        {
          return -603;
        }
        err = H5Lite::writeScalarAttribute(parentId, DREAM3D::FieldData::NumNeighbors, std::string(H5_NUMCOMPONENTS), 1);
        if(err < 0)
        {
          return -605;
        }
        err = H5Lite::writeStringAttribute(parentId, DREAM3D::FieldData::NumNeighbors, DREAM3D::HDF5::ObjectType, "DataArray<T>");
        if(err < 0)
        {
          return -604;
        }
      }

      // Allocate an array of the proper size to we can concatenate all the arrays together into a single array that
      // can be written to the HDF5 File. This operation can ballon the memory size temporarily until this operation
      // is complete.
      std::vector<T> flat (total);
      size_t currentStart = 0;
      for(size_t dIdx = 0; dIdx < _data.size(); ++dIdx)
      {
        size_t nEle = _data[dIdx]->size();
        if (nEle == 0) { continue; }
        T* start = &(_data[dIdx]->front()); // Get the pointer to the front of the array
        //    T* end = start + nEle; // Get the pointer to the end of the array
        T* dst = &(flat.front()) + currentStart;
        ::memcpy(dst, start, nEle*sizeof(T));

        currentStart += _data[dIdx]->size();
      }

      int32_t rank = 1;
      hsize_t dims[1] = { total };
      if (total > 0)
      {
        err = H5Lite::writePointerDataset(parentId, GetName(), rank, dims, &(flat.front()));
        if(err < 0)
        {
          return -605;
        }
        err = H5Lite::writeScalarAttribute(parentId, GetName(), std::string(H5_NUMCOMPONENTS), 1);
        if(err < 0)
        {
          return -606;
        }

        err = H5Lite::writeStringAttribute(parentId, GetName(), DREAM3D::HDF5::ObjectType, getNameOfClass());
        if(err < 0)
        {
          return -607;
        }

        err = H5Lite::writeStringAttribute(parentId, GetName(), "Linked NumNeighbors Dataset", DREAM3D::FieldData::NumNeighbors);
        if(err < 0)
        {
          return -608;
        }
      }
      return err;
    }
Beispiel #28
0
void test_forwardDyn() {

	const int MAXNS = NUMSTATE(WmrModel::MAXNF);
	const int MAXNV = NUMQVEL(WmrModel::MAXNF);

	//make WmrModel object
	WmrModel mdl;
	Real state[MAXNS];
	Real qvel[MAXNV];
	
	zoe(mdl,state,qvel);
	//rocky(mdl,state,qvel);
	//talon(mdl,state,qvel); //TODO

	//setVec(nv,0.0,qvel); //DEBUGGING
	mdl.actuatorModel=0; //ideal actuators

	//get from WmrModel
	const int nf = mdl.get_nf();
	const int ns = NUMSTATE(nf);
	const int nv = NUMQVEL(nf);

	const int nw = mdl.get_nw();
	const int nt = mdl.get_nt();

	//terrain
	SurfaceVector surfs;

	flat(surfs);
	//ramp(surfs);
	//grid(surfs, ResourceDir() + std::string("gridsurfdata.txt") );

	//init contact geometry
	WheelContactGeom wcontacts[WmrModel::MAXNW];
	TrackContactGeom tcontacts[WmrModel::MAXNW];
	ContactGeom* contacts = 0;

	if (nw > 0) {
		contacts = static_cast<ContactGeom*>(wcontacts);
	} else if (nt > 0) {
		sub_initTrackContactGeom(mdl, tcontacts);
		contacts = static_cast<ContactGeom*>(tcontacts);
	}

	//initTerrainContact(mdl, surfs, contacts, state); //DEBUGGING

	//convert state to Homogeneous Transforms
	HomogeneousTransform HT_parent[WmrModel::MAXNF + WmrModel::MAXNW];
	HomogeneousTransform HT_world[WmrModel::MAXNF + WmrModel::MAXNW];
	stateToHT(mdl,state,HT_parent,HT_world);

	//update contact geometry
	updateModelContactGeom(mdl, surfs, HT_world, 0, contacts);

	//controller inputs
	ControllerIO u;
	Real time = 0;
	
	mdl.controller(mdl, 0, state, u.cmd, 0);

	//additional inputs
	setVec(mdl.get_na(),0.0,u.interr);

	Real dt = .04; //time step

	//outputs
	Real qacc[MAXNV];

	forwardDyn(mdl, state, qvel, u, HT_parent, HT_world, contacts, dt, qacc);

	//DEBUGGING, print
	std::cout << "state=\n"; printMatReal(ns,1,state,-1,-1); std::cout << std::endl;
	std::cout << "qvel=\n"; printMatReal(nv,1,qvel,-1,-1); std::cout << std::endl;
	std::cout << "qacc=\n"; printMatReal(nv,1,qacc,-1,-1); std::cout << std::endl;


	if (1) {
		//time it
		int n= (int) 1e4;
		timeval t0, t1;

		gettimeofday(&t0, NULL);
		for (int i=0; i<n; i++) {
			forwardDyn(mdl, state, qvel, u, HT_parent, HT_world, contacts, dt, qacc);
		}
		gettimeofday(&t1, NULL);
		std::cout << "forwardDyn()\n";
		std::cout << "iterations: " << (Real) n << std::endl;
		std::cout << "clock (sec): " << tosec(t1)-tosec(t0) << std::endl;
	}
}
Beispiel #29
0
/*
 * do_chase:
 *	Make one thing chase another.
 */
int
do_chase(THING *th)
{
    coord *cp;
    struct room *rer, *ree;	/* room of chaser, room of chasee */
    int mindist = 32767, curdist;
    int stoprun = FALSE;	/* TRUE means we are there */
    int door;
    THING *obj;
    coord this;			/* Temporary destination for chaser */

    rer = th->t_room;		/* Find room of chaser */
    if (on(*th, ISGREED) && rer->r_goldval == 0)
	th->t_dest = &hero;	/* If gold has been taken, run after hero */
    if (th->t_dest == &hero)	/* Find room of chasee */
	ree = proom;
    else
	ree = roomin(th->t_dest);
    /*
     * We don't count doors as inside rooms for this routine
     */
    door = (chat(th->t_pos.y, th->t_pos.x) == DOOR);
    /*
     * If the object of our desire is in a different room,
     * and we are not in a corridor, run to the door nearest to
     * our goal.
     */
over:
    if (rer != ree)
    {
	for (cp = rer->r_exit; cp < &rer->r_exit[rer->r_nexits]; cp++)
	{
	    curdist = dist_cp(th->t_dest, cp);
	    if (curdist < mindist)
	    {
		this = *cp;
		mindist = curdist;
	    }
	}
	if (door)
	{
	    rer = &passages[flat(th->t_pos.y, th->t_pos.x) & F_PNUM];
	    door = FALSE;
	    goto over;
	}
    }
    else
    {
	this = *th->t_dest;
	/*
	 * For dragons check and see if (a) the hero is on a straight
	 * line from it, and (b) that it is within shooting distance,
	 * but outside of striking range.
	 */
	if (th->t_type == 'D' && (th->t_pos.y == hero.y || th->t_pos.x == hero.x
	    || abs(th->t_pos.y - hero.y) == abs(th->t_pos.x - hero.x))
	    && dist_cp(&th->t_pos, &hero) <= BOLT_LENGTH * BOLT_LENGTH
	    && !on(*th, ISCANC) && rnd(DRAGONSHOT) == 0)
	{
	    delta.y = sign(hero.y - th->t_pos.y);
	    delta.x = sign(hero.x - th->t_pos.x);
	    if (has_hit)
		endmsg();
	    fire_bolt(&th->t_pos, &delta, "flame");
	    running = FALSE;
	    count = 0;
	    quiet = 0;
	    if (to_death && !on(*th, ISTARGET))
	    {
		to_death = FALSE;
		kamikaze = FALSE;
	    }
	    return(0);
	}
    }
    /*
     * This now contains what we want to run to this time
     * so we run to it.  If we hit it we either want to fight it
     * or stop running
     */
    if (!chase(th, &this))
    {
	if (ce(this, hero))
	{
	    return( attack(th) );
	}
	else if (ce(this, *th->t_dest))
	{
	    for (obj = lvl_obj; obj != NULL; obj = next(obj))
		if (th->t_dest == &obj->o_pos)
		{
		    detach(lvl_obj, obj);
		    attach(th->t_pack, obj);
		    chat(obj->o_pos.y, obj->o_pos.x) =
			(th->t_room->r_flags & ISGONE) ? PASSAGE : FLOOR;
		    th->t_dest = find_dest(th);
		    break;
		}
	    if (th->t_type != 'F')
		stoprun = TRUE;
	}
    }
    else
    {
	if (th->t_type == 'F')
	    return(0);
    }
    relocate(th, &ch_ret);
    /*
     * And stop running if need be
     */
    if (stoprun && ce(th->t_pos, *(th->t_dest)))
	th->t_flags &= ~ISRUN;
    return(0);
}
Beispiel #30
0
void test_trackJacobians() {

	const int MAXNS = NUMSTATE(WmrModel::MAXNF);

	//make WmrModel object
	WmrModel mdl;
	Real state[MAXNS];
	
	talon(mdl,state,0);

	//get from WmrModel
	const int nt = mdl.get_nt();

	//terrain
	SurfaceVector surfs;

	flat(surfs);
	//ramp(surfs);
	//grid(surfs, ResourceDir() + std::string("gridsurfdata.txt") );

	//convert state to homogeneous transforms
	HomogeneousTransform HT_parent[WmrModel::MAXNF + WmrModel::MAXNW];
	HomogeneousTransform HT_world[WmrModel::MAXNF + WmrModel::MAXNW];
	stateToHT(mdl,state,HT_parent,HT_world);

	//contact geometry
	TrackContactGeom tcontacts[WmrModel::MAXNW];
	sub_initTrackContactGeom(mdl, tcontacts);

	ContactGeom* contacts = static_cast<ContactGeom*>(tcontacts);

	updateModelContactGeom(mdl, surfs, HT_world, mdl.min_npic, contacts);

	//number of points in contact
	int npic = 0;
	for (int tno = 0; tno < nt; tno++) {
		npic += logicalCount(tcontacts[tno].get_np(), tcontacts[tno].incontact);
	}

	//allocate matrix
	const int MAXNV = NUMQVEL(WmrModel::MAXNF);
	const int MAXNP = WmrModel::MAXNT * ContactGeom::MAXNP; //max number of contact points
	Real A[3*MAXNP * MAXNV];

	trackJacobians(mdl, HT_world, tcontacts, A);

	//DEBUGGING, print
	int ncc = 3*npic; //number of contact constraints
	int nv = NUMQVEL(mdl.get_nf());
	
	std::cout << "A=\n";
	printMatReal(ncc,nv,A,-1,-1);
	std::cout << std::endl;
	
	
	if (1) {
		//time it
		int n= (int) 1e6;
		timeval t0, t1;

		gettimeofday(&t0, NULL);
		for (int i=0; i<n; i++) {
			trackJacobians(mdl, HT_world, tcontacts, A);
		}
		gettimeofday(&t1, NULL);
		std::cout << "trackJacobians()\n";
		std::cout << "iterations: " << (Real) n << std::endl;
		std::cout << "clock (sec): " << tosec(t1)-tosec(t0) << std::endl;
	}
	

}