int main(){
	int n = 6;
	int m = n;
	Matrix x = Linspace(-4.0, 4.0, m+1, 1);
	Matrix y = Linspace(-4.0, 4.0, n+1, 1);
	Matrix f(x.Size(), y.Size());
	for(int i = 0; i < x.Size(); i++){
		for(int j = 0; j < y.Size(); j++){
			f(i, j) = 1/(1+(x(i)*x(i)) + (y(j)*y(j)));
		}
	}
	Matrix a = Linspace(-4.0, 4.0, 201, 1);
	a.Write("avals.txt");
	Matrix b = Linspace(-4.0, 4.0, 101, 1);
	b.Write("bvals.txt");
	Matrix p6(a.Size(), b.Size());
	for(int i = 0; i < a.Size(); i++){
		for(int j = 0; j < b.Size(); j++){
			p6(i, j) = Lagrange2D(x, y, f, a(i), b(j));
		}
	}
	p6.Write("p6_uni.txt");

	n = 24;
	m = n;
	x = Linspace(-4.0, 4.0, m+1, 1);
	y = Linspace(-4.0, 4.0, n+1, 1);
	f = Matrix(x.Size(), y.Size());
	for(int i = 0; i < x.Size(); i++){
		for(int j = 0; j < y.Size(); j++){
			f(i, j) = 1/(1+(x(i)*x(i)) + (y(j)*y(j)));
		}
	}
	Matrix p24(a.Size(), b.Size());
	for(int i = 0; i < a.Size(); i++){
		for(int j = 0; j < b.Size(); j++){
			p24(i, j) = Lagrange2D(x, y, f, a(i), b(j));
		}
	}
	p24.Write("p24_uni.txt");

	Matrix runge(201, 101);
	for(int i = 0; i < a.Size(); i++){
		for(int j = 0; j < b.Size(); j++){
			runge(i, j) = 1/(1+(a(i)*a(i)) + (b(j)*b(j)));
		}
	}
	//create runge matrix
	runge.Write("Runge.txt");



}
Пример #2
0
  void addWeighted(WpointVector &list,ConvexDecompInterface *callback)
  {

    Wpoint p1(mP1,mC1);
    Wpoint p2(mP2,mC2);
    Wpoint p3(mP3,mC3);

		Vector3d d1 = mNear1 - mP1;
		Vector3d d2 = mNear2 - mP2;
		Vector3d d3 = mNear3 - mP3;

		d1*=WSCALE;
		d2*=WSCALE;
		d3*=WSCALE;

		d1 = d1 + mP1;
		d2 = d2 + mP2;
 	  d3 = d3 + mP3;

    Wpoint p4(d1,mC1);
    Wpoint p5(d2,mC2);
    Wpoint p6(d3,mC3);

    list.push_back(p1);
    list.push_back(p2);
    list.push_back(p3);

    list.push_back(p4);
    list.push_back(p5);
    list.push_back(p6);

#if 0
		callback->ConvexDebugPoint(mP1.Ptr(),0.01f,0x00FF00);
		callback->ConvexDebugPoint(mP2.Ptr(),0.01f,0x00FF00);
		callback->ConvexDebugPoint(mP3.Ptr(),0.01f,0x00FF00);
		callback->ConvexDebugPoint(d1.Ptr(),0.01f,0xFF0000);
		callback->ConvexDebugPoint(d2.Ptr(),0.01f,0xFF0000);
		callback->ConvexDebugPoint(d3.Ptr(),0.01f,0xFF0000);

		callback->ConvexDebugTri(mP1.Ptr(), d1.Ptr(),  d1.Ptr(),0x00FF00);
		callback->ConvexDebugTri(mP2.Ptr(), d2.Ptr(),  d2.Ptr(),0x00FF00);
		callback->ConvexDebugTri(mP3.Ptr(), d3.Ptr(),  d3.Ptr(),0x00FF00);

		Vector3d np1 = mP1 + mNormal*0.05f;
		Vector3d np2 = mP2 + mNormal*0.05f;
		Vector3d np3 = mP3 + mNormal*0.05f;

		callback->ConvexDebugTri(mP1.Ptr(), np1.Ptr(), np1.Ptr(), 0xFF00FF );
		callback->ConvexDebugTri(mP2.Ptr(), np2.Ptr(), np2.Ptr(), 0xFF00FF );
		callback->ConvexDebugTri(mP3.Ptr(), np3.Ptr(), np3.Ptr(), 0xFF00FF );

		callback->ConvexDebugPoint( np1.Ptr(), 0.01F, 0XFF00FF );
		callback->ConvexDebugPoint( np2.Ptr(), 0.01F, 0XFF00FF );
		callback->ConvexDebugPoint( np3.Ptr(), 0.01F, 0XFF00FF );

#endif



  }
Пример #3
0
int main()
{
    FitParameter p0 (2,0.2,"0p2",0.2,0.2,0.2,0.2);
    FitParameter p1 (3,0.3,"0p3",0.3,0.3,0.3,0.3);

    std::cout << "Before"
            << "\n" << p0
            << "\n" << p1
            << std::endl;

    p0.swap(p1);

    std::cout << "After"
            << "\n" << p0
            << "\n" << p1
            << std::endl;


    Parameter p5 (5,0.5,"0p5",0.5);
    Parameter p6 (6,0.6,"0p6",0.6);

    std::cout << "Before"
            << "\n" << p5
            << "\n" << p6
            << std::endl;

    p5.swap(p6);

    std::cout << "After"
            << "\n" << p5
            << "\n" << p6
            << std::endl;

    std::cout << "////////////////////////" << std::endl;
    std::cout << "Parameters"  << std::endl;

    Parameters pars0;
    pars0.AddParameter(p0);
    pars0.AddParameter(p1);

    Parameters pars1;
    pars1.AddParameter(p5);
    pars1.AddParameter(p6);

    std::cout << "Before"
            << "\n" << pars0
            << "\n" << pars1
            << std::endl;

    pars0.swap(pars1);

    std::cout << "After"
            << "\n" << pars0
            << "\n" << pars1
            << std::endl;



    return 0;
}
Пример #4
0
    PrimitiveParts cubePrimitive(float width, float height, float depth)
    {
        float hx = width / 2;
        float hy = height / 2;
        float hz = depth / 2;

        // create the vertices
        Point3 p0(hx,hy,hz);
        Point3 p1(hx,hy,-hz);
        Point3 p2(-hx,hy,-hz);
        Point3 p3(-hx,hy,hz);
        Point3 p4(hx,-hy,hz);
        Point3 p5(hx,-hy,-hz);
        Point3 p6(-hx,-hy,-hz);
        Point3 p7(-hx,-hy,hz);

        QList<int> f0 = QList<int>() << 0 << 1 << 2 << 3;
        QList<int> f1 = QList<int>() << 4 << 5 << 1 << 0;
        QList<int> f2 = QList<int>() << 6 << 2 << 1 << 5;
        QList<int> f3 = QList<int>() << 7 << 3 << 2 << 6;
        QList<int> f4 = QList<int>() << 7 << 4 << 0 << 3;
        QList<int> f5 = QList<int>() << 4 << 7 << 6 << 5;

        PrimitiveParts parts;
        parts.points = QVector<Point3>() << p0 << p1 << p2 << p3 << p4 << p5 << p6 << p7;
        parts.faces = QVector<QList<int> >() << f0 << f1 << f2 << f3 << f4 << f5;
        return parts;
    }
Пример #5
0
void Bezier::split(double t, Bezier & left, Bezier & right) const
{
	// http://processingjs.nihongoresources.com/bezierinfo/sketchsource.php?sketch=CubicDeCasteljau

	// interpolate from 4 to 3 points
	QPointF p5((1-t)*m_endpoint0.x() + t*m_cp0.x(), (1-t)*m_endpoint0.y() + t*m_cp0.y());
	QPointF p6((1-t)*m_cp0.x() + t*m_cp1.x(), (1-t)*m_cp0.y() + t*m_cp1.y());
	QPointF p7((1-t)*m_cp1.x() + t*m_endpoint1.x(), (1-t)*m_cp1.y() + t*m_endpoint1.y());

	// interpolate from 3 to 2 points
	QPointF p8((1-t)*p5.x() + t*p6.x(), (1-t)*p5.y() + t*p6.y());
	QPointF p9((1-t)*p6.x() + t*p7.x(), (1-t)*p6.y() + t*p7.y());

	// interpolate from 2 points to 1 point
	QPointF p10((1-t)*p8.x() + t*p9.x(), (1-t)*p8.y() + t*p9.y());

	// we now have all the values we need to build the subcurves
	left.m_endpoint0 = m_endpoint0;
	left.m_cp0 = p5;
	left.m_cp1 = p8;
	right.m_endpoint0 = left.m_endpoint1 = p10;
	right.m_cp0 = p9;
	right.m_cp1 = p7;
	right.m_endpoint1 = m_endpoint1;
	left.m_isEmpty = right.m_isEmpty = false;
} 
Пример #6
0
std::vector<Eigen::Vector2i> PathPlanner::getNeighbours(Eigen::Vector2i p)
{
    Eigen::Vector2i p0(p(0) + 1, p(1));
    Eigen::Vector2i p1(p(0) - 1, p(1));
    Eigen::Vector2i p2(p(0), p(1) + 1);
    Eigen::Vector2i p3(p(0), p(1) - 1);

    Eigen::Vector2i p4(p(0) + 1, p(1) + 1);
    Eigen::Vector2i p5(p(0) - 1, p(1) - 1);
    Eigen::Vector2i p6(p(0) - 1, p(1) + 1);
    Eigen::Vector2i p7(p(0) + 1, p(1) - 1);

    std::vector<Eigen::Vector2i> points;

    if(validPoint(p0))
        points.push_back(p0);
    if(validPoint(p1))
        points.push_back(p1);
    if(validPoint(p2))
        points.push_back(p2);
    if(validPoint(p3))
        points.push_back(p3);

    //Disallow walking through diagonal cracks
    if(validPoint(p4) && (validPoint(p0) || validPoint(p2)))
        points.push_back(p4);
    if(validPoint(p5) && (validPoint(p1) || validPoint(p3)))
        points.push_back(p5);
    if(validPoint(p6) && (validPoint(p1) || validPoint(p2)))
        points.push_back(p6);
    if(validPoint(p7) && (validPoint(p0) || validPoint(p3)))
        points.push_back(p7);

    return points;
}
Пример #7
0
int main()
{
  // Construct an arrangement of seven intersecting line segments.
  Point_2 p1(1, 1), p2(1, 4), p3(2, 2), p4(3, 7), p5(4, 4), p6(7, 1), p7(9, 3);
  Ex_arrangement  arr;
  insert(arr, Segment_2(p1, p6));
  insert(arr, Segment_2(p1, p4));  insert(arr, Segment_2(p2, p6));
  insert(arr, Segment_2(p3, p7));  insert(arr, Segment_2(p3, p5));
  insert(arr, Segment_2(p6, p7));  insert(arr, Segment_2(p4, p7));

  // Create a mapping of the arrangement faces to indices.
  Face_index_map  index_map(arr);

  // Perform breadth-first search from the unbounded face, using the event
  // visitor to associate each arrangement face with its discover time.
  unsigned int    time = 0;
  boost::breadth_first_search(Dual_arrangement(arr), arr.unbounded_face(),
                              boost::vertex_index_map(index_map).visitor
                              (boost::make_bfs_visitor
                               (stamp_times(Face_property_map(), time,
                                            boost::on_discover_vertex()))));

  // Print the discover time of each arrangement face.
  Ex_arrangement::Face_iterator  fit;
  for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) {
    std::cout << "Discover time " << fit->data() << " for ";
    if (fit != arr.unbounded_face()) {
      std::cout << "face ";
      print_ccb<Ex_arrangement>(fit->outer_ccb());
    }
    else std::cout << "the unbounded face." << std::endl;
  }
  return 0;
}
Пример #8
0
void measurement_overhead() {
    printf("Measurement, 0, 0\n");

    PM("","RDTSC, "O_STR);

    #define FOR_MEAS for (int k = 0; k < 100; ++k) { ; }
    double m; uint64_t med, se, min, max;
    measure(FOR_MEAS,m,med,se,min,max,10000);
    printf("Loop, "O_STR, m/100, med/100, se/100, min/100, max/100);

    printf("Function Calls, 0, 0\n");

    PM_COUNT(p0(), "p0, "O_STR,1000000);

    PM_COUNT(p1(1), "p1, "O_STR,1000000);

    PM_COUNT(p2(1,2), "p2, "O_STR,1000000);

    PM_COUNT(p3(1,2,3), "p3, "O_STR,1000000);

    PM_COUNT(p4(1,2,3,4), "p4, "O_STR,1000000);

    PM_COUNT(p5(1,2,3,4,5), "p5, "O_STR,1000000);

    PM_COUNT(p6(1,2,3,4,5,6), "p6, "O_STR,1000000);

    PM_COUNT(p7(1,2,3,4,5,6,7), "p7, "O_STR,1000000);
}
Пример #9
0
BDic* find_nodeQueryPacket(char node[20], char target[20]) {


    BDic* res = neutralPacket();

    BString* a3a = new BString ("q");
    BString* a3b = new BString ("find_node");;
    std::pair<BString*, Bencodable *> p3(a3a, a3b);
    res->push_back(p3);

    BString* a4a = new BString ("a");
    BDic* a4b = new BDic;

    BString* a5a = new BString ("id");
    BString* a5b = new BString (node);
    std::pair<BString*, Bencodable *> p5(a5a, a5b);
    a4b->push_back(p5);

    BString* a6a = new BString ("target");
    BString* a6b = new BString (target);
    std::pair<BString*, Bencodable *> p6(a6a, a6b);
    a4b->push_back(p6);

    std::pair<BString*, Bencodable *> p4(a4a, a4b);
    res->push_back(p4);


    return res;

}
Пример #10
0
int main()
{
    vec v1(1, 1), v2(0, 2);
    cout << "vec1(1,1) cross vec2(0,2): " << cross(v1, v2) << endl << endl;
    node p0(0, 0), p1(0, 1), p2(1, 2), p3(2, 1), p4(2, 0), p5(1, 0), p6(1, 1);
    node s[7];
    s[0] = p4, s[1] = p3, s[2] = p2, s[3] = p1, s[4] = p0, s[5] = p5, s[6] = p6;
    segment l0(p0, p3), l1(p5, p6), l2(p6, p4), l3(p1, p2);
    test_segment(l0, l1);
    test_segment(l1, l2);
    test_segment(l0, l3);

    segment ll[4];
    ll[0] = l0, ll[1] = l1, ll[2] = l2, ll[3] = l3;
    for(int i = 0; i < 4; ++ i) {
        ll[i].s_lt.n_idx = i;
        ll[i].s_rt.n_idx = i;
        ll[i].s_lt.n_lt = 1;
        ll[i].s_rt.n_lt = 0;
    }
    cout << "sweeping:" << endl;
    for(int i = 0; i < 4; ++ i)
        ll[i].s_print();
    if(sweeping(ll, 4))
        cout << "yes" << endl;
    else
        cout << "no" << endl;

    return(0);
}
Пример #11
0
void generateTriPrism(GLuint program, ShapeData* triPrismData)
{
	int Index = 0;
	point3 p1(1.0f, -0.5f, 0.0f);
	point3 p2(0.0f, -0.5f, 0.0f);
	point3 p3(0.0f, -0.5f, 1.0f);
	point3 p4(1.0f,  0.5f, 0.0f);
	point3 p5(0.0f,  0.5f, 0.0f);
	point3 p6(0.0f,  0.5f, 1.0f);

	// Bottom of the triangular prism
	triPrismPoints[Index] = p1; triPrismNormals[Index] = point3(0.0f, -1.0f, 0.0f); Index++;
	triPrismPoints[Index] = p3; triPrismNormals[Index] = point3(0.0f, -1.0f, 0.0f); Index++;
	triPrismPoints[Index] = p2; triPrismNormals[Index] = point3(0.0f, -1.0f, 0.0f); Index++;

	// Top of the triangular prism
	triPrismPoints[Index] = p4; triPrismNormals[Index] = point3(0.0f, 1.0f, 0.0f); Index++;
	triPrismPoints[Index] = p5; triPrismNormals[Index] = point3(0.0f, 1.0f, 0.0f); Index++;
	triPrismPoints[Index] = p6; triPrismNormals[Index] = point3(0.0f, 1.0f, 0.0f); Index++;

	// Back of the triangular prism
	triPrismPoints[Index] = p1; triPrismNormals[Index] = point3(0.0f, 0.0f, -1.0f); Index++;
	triPrismPoints[Index] = p2; triPrismNormals[Index] = point3(0.0f, 0.0f, -1.0f); Index++;
	triPrismPoints[Index] = p4; triPrismNormals[Index] = point3(0.0f, 0.0f, -1.0f); Index++;

	triPrismPoints[Index] = p2; triPrismNormals[Index] = point3(0.0f, 0.0f, -1.0f); Index++;
	triPrismPoints[Index] = p5; triPrismNormals[Index] = point3(0.0f, 0.0f, -1.0f); Index++;
	triPrismPoints[Index] = p4; triPrismNormals[Index] = point3(0.0f, 0.0f, -1.0f); Index++;

	// Left of the triangular prism
	triPrismPoints[Index] = p2; triPrismNormals[Index] = point3(-1.0f, 0.0f, 0.0f); Index++;
	triPrismPoints[Index] = p3; triPrismNormals[Index] = point3(-1.0f, 0.0f, 0.0f); Index++;
	triPrismPoints[Index] = p6; triPrismNormals[Index] = point3(-1.0f, 0.0f, 0.0f); Index++;

	triPrismPoints[Index] = p2; triPrismNormals[Index] = point3(-1.0f, 0.0f, 0.0f); Index++;
	triPrismPoints[Index] = p6; triPrismNormals[Index] = point3(-1.0f, 0.0f, 0.0f); Index++;
	triPrismPoints[Index] = p5; triPrismNormals[Index] = point3(-1.0f, 0.0f, 0.0f); Index++;

	// Front of the triangular prism
	triPrismPoints[Index] = p1; triPrismNormals[Index] = point3(1.0f, 0.0f, 1.0f); Index++;
	triPrismPoints[Index] = p6; triPrismNormals[Index] = point3(1.0f, 0.0f, 1.0f); Index++;
	triPrismPoints[Index] = p3; triPrismNormals[Index] = point3(1.0f, 0.0f, 1.0f); Index++;

	triPrismPoints[Index] = p1; triPrismNormals[Index] = point3(1.0f, 0.0f, 1.0f); Index++;
	triPrismPoints[Index] = p4; triPrismNormals[Index] = point3(1.0f, 0.0f, 1.0f); Index++;
	triPrismPoints[Index] = p6; triPrismNormals[Index] = point3(1.0f, 0.0f, 1.0f); Index++;

    triPrismData->numVertices = numTriPrismVertices;

    glGenVertexArrays( 1, &triPrismData->vao );
    glBindVertexArray( triPrismData->vao );

    setVertexAttrib(program,
    				(float*)triPrismPoints, sizeof(triPrismPoints),
    				(float*)triPrismNormals, sizeof(triPrismNormals),
    				0, 0);
}
Пример #12
0
void RectangleSlice::generateOuterWall45(int wall_width)
{
  
  Eigen::Rotation2D<float> R(0.7854);

  Eigen::Vector2f p0((LINE_WIDTH * 2 * wall_width), (LINE_WIDTH * 2 * wall_width));
  p0 = R * p0;

  
  moveToStart45();
  _width -= p0(0);
  _length -= p0(1);
  for(int i = 0; i < wall_width; i++)
  {
    Eigen::Vector2f p1(0.0, _width);
    Eigen::Vector2f p2(-_length, 0.0);
    Eigen::Vector2f p3(0.0, -_width);
    Eigen::Vector2f p4(_length, 0.0);

    Eigen::Vector2f p5(LINE_WIDTH, -LINE_WIDTH);
    Eigen::Vector2f p6((LINE_WIDTH * 2), (LINE_WIDTH * 2));
    
    
    p1 = R * p1;
    p2 = R * p2;
    p3 = R * p3;
    p4 = R * p4;
    p5 = R * p5;
    p6 = R * p6;

    _ph->extrudeAlongXYAxis(p1(0), p1(1));
    _ph->extrudeAlongXYAxis(p2(0), p2(1));
    _ph->extrudeAlongXYAxis(p3(0), p3(1));
    _ph->extrudeAlongXYAxis(p4(0), p4(1));
    _ph->moveAlongXYAxis(p5(0), p5(1));
    _width += p6(0);
    _length += p6(0);

  }
  _ph->moveZAxis();
}
Пример #13
0
int main()
{
  try
    {
      symbol k("k"),q("q"),p("p"),p1("p1"),p2("p2"),p3("p3"),ms("ms"),l("l"),s("s"),m1s("m1s"),m2s("m2s"),m3s("m3s");
      symbol l1("l1"),l2("l2"),l3("l3"),l4("l4"),t("t"),p4("p4"),p5("p5"),p6("p6"),tp("tp"),v1("v1"),v2("v2"),l5("l5");
      symbol k1("k1"),k2("k2"),k3("k3"),k4("k4"),k5("k5"),ms1("ms1"),ms2("ms2"),ms3("ms3"),ms4("ms4");
      symbol s12("s12"),s23("s23"),s34("s34"),s45("s45"),s51("s51"),s13("s13"),s15("s15"),s56("s56"),s16("s16"),s123("s123"),s234("s234"),s345("s345");
      lst inv_l;
      inv_l.append(p1*p1 == 0);
      inv_l.append( p2*p2 == 0);inv_l.append( p3*p3  ==  0);inv_l.append( p4*p4  ==  0);inv_l.append( p5*p5  ==  0);inv_l.append( p6*p6  ==  0);
      inv_l.append(p1* p2  ==  s12/2);inv_l.append( p2* p3  ==  s23/2);inv_l.append( p3* p4  ==  s34/2);inv_l.append( p4* p5  ==  s45/2);
      inv_l.append(p5* p6  ==  s56/2);inv_l.append( p1* p6  ==  s16/2);inv_l.append( p1* p3  ==  (-s12 + s123 - s23)/2);
      inv_l.append(p2* p4  ==  (-s23 + s234 - s34)/2);
      inv_l.append( p3* p5  ==  (-s34 + s345 - s45)/2);
      inv_l.append(p1* p4  ==  (-s123 + s23 - s234 + s56)/2);
      inv_l.append(p1* p5  ==  (-s16 + s234 - s56)/2);
      inv_l.append( p2* p5  ==  (s16 - s234 + s34 - s345)/2);
      inv_l.append( p2* p6  ==  (-s12 - s16 + s345)/2);
      inv_l.append( p3* p6  ==  (s12 - s123 - s345 + s45)/2);
      inv_l.append( p4* p6  ==  (s123 - s45 - s56)/2);
      
      
      RoMB_loop_by_loop hexag(lst(k1),
                              lst(-pow(p1 + k1,2),-pow(p1 + p2 + k1,2),
                                  -pow(p1 + p2 + p3 + k1,2),
                                  -pow(p1 + p2 + p3 + p4 + k1,2),
                                  -pow(p1+p2+p3+p4+p5+k1,2),-pow(k1,2)),
                              inv_l,
                              lst(1,1,1,1,1,1),true);
      hexag.integrate_map(lst(s12 == -1, s23 == -2, s34 == -3, s45 == -4, s56 == -5, s16 == -6, s123 == -7, s234 == -8, s345 == -9));
/*

 FRESULT for parameters: {s12==-1,s23==-2,s34==-3,s45==-4,s56==-5,s16==-6,s123==-7,s234==-8,s345==-9}
 
  FRESULT anl :           = -0.1955084880526298663-1/240*log(8)*log(6)+947/60480*log(2)^2-1/480*log(6)*log(4)+1/1080*log(3)*log(7)+131/7560*log(9)*log(2)+19/1260*log(9)^2-1/560*log(8)*log(4)+523/60480*log(3)^2-1/1080*log(7)*log(5)+41/4320*log(3)*log(5)-1/48*log(8)*log(5)-1/1080*log(7)*log(4)+22/945*log(6)*log(7)+19/3780*log(3)*log(4)+493/30240*Pi^2+43/1008*eps^(-2)+49/8640*log(5)^2-641/30240*log(2)*log(6)+1/1080*log(9)*log(5)-22/945*log(2)*log(7)+271/60480*log(4)^2-3/112*log(8)*log(3)-19/3780*log(9)*log(4)+1/1080*log(4)*log(5)-61/2520*log(9)*log(7)+61/5040*log(7)^2+1/168*log(3)*log(2)+1/168*log(8)*log(9)+13/3360*log(2)*log(4)-1/30240*(-1132.7960047725738361+576*log(8)-163*log(3)+264*log(9)+533*log(2)-479*log(6)-444*log(7)+271*log(4)-287*log(5))*eps^(-1)+47/1680*log(8)^2-17/1680*log(8)*log(2)+767/60480*log(6)^2-22/945*log(9)*log(6)-13/1890*log(3)*log(9)
   FRESULT num:           = 1.9907333428263254975E-4+(0.032177795803854872908)*eps^(-1)+(0.04265873015873015873)*eps^(-2)
    eps^-2 term: 43/1008 +/- 0
     eps^-1 term: 0.03746018534300839405-2/105*log(8)+163/30240*log(3)-11/1260*log(9)-533/30240*log(2)+479/30240*log(6)+37/2520*log(7)-271/30240*log(4)+41/4320*log(5) +/- 9.022403780167233619E-6
      eps^0 term: -0.1955084880526298663-1/240*log(8)*log(6)+947/60480*log(2)^2-1/480*log(6)*log(4)+1/1080*log(3)*log(7)+131/7560*log(9)*log(2)+19/1260*log(9)^2-1/560*log(8)*log(4)+523/60480*log(3)^2-1/1080*log(7)*log(5)+41/4320*log(3)*log(5)-1/48*log(8)*log(5)-1/1080*log(7)*log(4)+22/945*log(6)*log(7)+19/3780*log(3)*log(4)+493/30240*Pi^2+49/8640*log(5)^2-641/30240*log(2)*log(6)+1/1080*log(9)*log(5)-22/945*log(2)*log(7)+271/60480*log(4)^2-3/112*log(8)*log(3)-19/3780*log(9)*log(4)+1/1080*log(4)*log(5)-61/2520*log(9)*log(7)+61/5040*log(7)^2+1/168*log(3)*log(2)+1/168*log(8)*log(9)+13/3360*log(2)*log(4)+47/1680*log(8)^2-17/1680*log(8)*log(2)+767/60480*log(6)^2-22/945*log(9)*log(6)-13/1890*log(3)*log(9) +/- 1.04620404922048185285E-4
      */

    }
  catch(std::exception &p)
    {
      std::cerr<<"******************************************************************"<<endl;
      std::cerr<<"   >>>ERROR:  "<<p.what()<<endl;
      std::cerr<<"******************************************************************"<<endl;
      return 1;
    }
  return 0;
}
Пример #14
0
void KisNodeDelegate::drawFrame(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    KisNodeViewColorScheme scm;

    QPen oldPen = p->pen();
    p->setPen(scm.gridColor(option, d->view));

    const QPoint base = option.rect.topLeft();

    QPoint p2 = base + QPoint(-scm.indentation() - 1, 0);
    QPoint p3 = base + QPoint(-2 * scm.border() - 2 * scm.decorationMargin() - scm.decorationSize(), 0);
    QPoint p4 = base + QPoint(-1, 0);
    QPoint p5(iconsRect(option,
                           index).left() - 1, base.y());
    QPoint p6(option.rect.right(), base.y());

    QPoint v(0, option.rect.height());

    const bool paintForParent =
        index.parent().isValid() &&
        !index.row();

    if (paintForParent) {
        QPoint p1(-2 * scm.indentation() - 1, 0);
        p1 += base;
        p->drawLine(p1, p2);
    }


    QPoint k0(0, base.y());
    QPoint k1(1 * scm.border() + 2 * scm.visibilityMargin() + scm.visibilitySize(), base.y());
    p->drawLine(k0, k1);
    p->drawLine(k0 + v, k1 + v);
    p->drawLine(k0, k0 + v);
    p->drawLine(k1, k1 + v);

    p->drawLine(p2, p6);
    p->drawLine(p2 + v, p6 + v);
    p->drawLine(p2, p2 + v);
    p->drawLine(p3, p3 + v);
    p->drawLine(p4, p4 + v);
    p->drawLine(p5, p5 + v);
    p->drawLine(p6, p6 + v);

    //// For debugging purposes only
    //p->setPen(Qt::blue);
    //KritaUtils::renderExactRect(p, iconsRect(option, index));
    //KritaUtils::renderExactRect(p, textRect(option, index));
    //KritaUtils::renderExactRect(p, scm.relThumbnailRect().translated(option.rect.topLeft()));

    p->setPen(oldPen);
}
Пример #15
0
void BBox::render()
{
	Vec3d p0(inf),
		p1(sup[0], inf[1], inf[2]),
		p2(sup[0], sup[1], inf[2]),
		p3(inf[0], sup[1], inf[2]),
		p4(inf[0], inf[1], sup[2]),
		p5(sup[0], inf[1], sup[2]),
		p6(sup),
		p7(inf[0], sup[1], sup[2]);
	glBegin(GL_LINES);

	glVertex3dv(&p0[0]);
	glVertex3dv(&p1[0]);

	glVertex3dv(&p1[0]);
	glVertex3dv(&p2[0]);

	glVertex3dv(&p2[0]);
	glVertex3dv(&p3[0]);

	glVertex3dv(&p3[0]);
	glVertex3dv(&p0[0]);

	glVertex3dv(&p4[0]);
	glVertex3dv(&p5[0]);

	glVertex3dv(&p5[0]);
	glVertex3dv(&p6[0]);

	glVertex3dv(&p6[0]);
	glVertex3dv(&p7[0]);

	glVertex3dv(&p7[0]);
	glVertex3dv(&p4[0]);

	glVertex3dv(&p0[0]);
	glVertex3dv(&p4[0]);

	glVertex3dv(&p1[0]);
	glVertex3dv(&p5[0]);

	glVertex3dv(&p2[0]);
	glVertex3dv(&p6[0]);

	glVertex3dv(&p3[0]);
	glVertex3dv(&p7[0]);

	glEnd();
}
Пример #16
0
	void ExplosionSystem::addExplosion(glm::vec3 origin)
	{
		MistEffect *g_MistEffect = new MistEffect(150);
		MistEmitter *g_MistEmitter = new MistEmitter();

		BurstEffect *g_BurstEffect = new BurstEffect(40);
		BurstEmitter *g_BurstEmitter = new BurstEmitter();

		ShockwaveEffect *g_ShockwaveEffect = new ShockwaveEffect(1);
		ShockwaveEmitter *g_ShockwaveEmitter = new ShockwaveEmitter();

		FlashEffect *g_FlashEffect = new FlashEffect(5);
		FlashEmitter *g_FlashEmitter = new FlashEmitter();

		ExplosionSparksEffect *g_ExplosionSparksEffect = new ExplosionSparksEffect(40);
		ExplosionSparksEmitter *g_ExplosionSparksEmitter = new ExplosionSparksEmitter();

		DebrisEffect *g_DebrisEffect = new DebrisEffect(25);
		DebrisEmitter *g_DebrisEmitter = new DebrisEmitter();

		TrailSystem *g_TrailSystem = new TrailSystem(15, origin);


		g_MistEmitter->setOrigin(origin);
		g_BurstEmitter->setOrigin(origin);
		g_ShockwaveEmitter->setOrigin(origin);
		g_FlashEmitter->setOrigin(origin);
		g_ExplosionSparksEmitter->setOrigin(origin);
		g_DebrisEmitter->setOrigin(origin);

		std::pair <MistEffect, MistEmitter> p1 (*g_MistEffect, *g_MistEmitter);
		std::pair <BurstEffect, BurstEmitter> p2 (*g_BurstEffect, *g_BurstEmitter);
		std::pair <ShockwaveEffect, ShockwaveEmitter> p3 (*g_ShockwaveEffect, *g_ShockwaveEmitter);
		std::pair <FlashEffect, FlashEmitter> p4 (*g_FlashEffect, *g_FlashEmitter);
		std::pair <ExplosionSparksEffect, ExplosionSparksEmitter> p5 (*g_ExplosionSparksEffect, *g_ExplosionSparksEmitter);
		std::pair <DebrisEffect, DebrisEmitter> p6 (*g_DebrisEffect, *g_DebrisEmitter);

		MistVector.push_back(p1);
		BurstVector.push_back(p2);
		ShockwaveVector.push_back(p3);
		FlashVector.push_back(p4);
		SparksVector.push_back(p5);
		DebrisVector.push_back(p6);

		g_TrailSystem->setCamera(camera);
		g_TrailSystem->addTrails();
		TrailSystemVector.push_back(*g_TrailSystem);
	}
Пример #17
0
void init_crown_mesh(GLShape& mesh) {
    float x0 = 0.1f;
    float y0 = 0.025f;
    float y1 = 0.05f;
    float x1 = 0.5f * x0;
    
    Vector2 p0(-x0, 0.0f);
    Vector2 p1(x0, 0.0f);
    Vector2 p2(x0, y1);
    Vector2 p3(x1, y0);
    Vector2 p4(0.0f, y1);
    Vector2 p5(-x1, y0);
    Vector2 p6(-x0, y1);
    
    mesh = to_xy(triangulate({p0, p1, p2, p3, p4, p5, p6}));
}
void PE_IO::fire_PI()
{	
	token_type x0,x1,x2,x3,x4,x5,x6,x7;
	x0.re=(rand()%10000)/10000.0000; x0.im=(rand()%10000)/10000.0000;
	x1.re=(rand()%10000)/10000.0000; x1.im=(rand()%10000)/10000.0000;
	x2.re=(rand()%10000)/10000.0000; x2.im=(rand()%10000)/10000.0000;
	x3.re=(rand()%10000)/10000.0000; x3.im=(rand()%10000)/10000.0000;
	x4.re=(rand()%10000)/10000.0000; x4.im=(rand()%10000)/10000.0000;
	x5.re=(rand()%10000)/10000.0000; x5.im=(rand()%10000)/10000.0000;
	x6.re=(rand()%10000)/10000.0000; x6.im=(rand()%10000)/10000.0000;
	x7.re=(rand()%10000)/10000.0000; x7.im=(rand()%10000)/10000.0000;
	
	packet p0(x_, y_, 1, 0, x0);
	printf("Round %d:PI: send x0 %.4f+%.4fi to (%d,%d)\n",
		pifire,x0.re,x0.im, p0.dest_x, p0.dest_y);
	packet p1(x_, y_, 1, 2, x1);
	printf("Round %d:PI: send x1 %.4f+%.4fi to (%d,%d)\n",
		pifire,x1.re,x1.im, p1.dest_x, p1.dest_y);
	packet p2(x_, y_, 2, 1, x2);
	printf("Round %d:PI: send x2 %.4f+%.4fi to (%d,%d)\n",
		pifire,x2.re,x2.im, p2.dest_x, p2.dest_y);
	packet p3(x_, y_, 0, 1, x3);
	printf("Round %d:PI: send x3 %.4f+%.4fi to (%d,%d)\n",
		pifire,x3.re,x3.im, p3.dest_x, p3.dest_y);
	packet p4(x_, y_, 1, 0, x4);
	printf("Round %d:PI: send x4 %.4f+%.4fi to (%d,%d)\n",
		pifire,x4.re,x4.im, p4.dest_x, p4.dest_y);
	packet p5(x_, y_, 1, 2, x5);
	printf("Round %d:PI: send x5 %.4f+%.4fi to (%d,%d)\n",
		pifire,x5.re,x5.im, p5.dest_x, p5.dest_y);
	packet p6(x_, y_, 2, 1, x6);
	printf("Round %d:PI: send x6 %.4f+%.4fi to (%d,%d)\n",
		pifire,x6.re,x6.im, p6.dest_x, p6.dest_y);
	packet p7(x_, y_, 0, 1, x7);
	printf("Round %d:PI: send x7 %.4f+%.4fi to (%d,%d)\n",
		pifire,x7.re,x7.im, p7.dest_x, p7.dest_y);
	out_queue_.push_back(p0);
	out_queue_.push_back(p1);
	out_queue_.push_back(p2);
	out_queue_.push_back(p3);
	out_queue_.push_back(p4);
	out_queue_.push_back(p5);
	out_queue_.push_back(p6);
	out_queue_.push_back(p7);
	
	pifire++;
}
Пример #19
0
void COGLCubeMap::LoadCubeMapFromPath(const std::string& path)
{
	std::string p1(path);
	std::string p2(path);
	std::string p3(path);
	std::string p4(path);
	std::string p5(path);
	std::string p6(path);

	LoadCubeMapFromFiles(
		p1.append("pos_x.png").c_str(), 
		p2.append("neg_x.png").c_str(),
		p3.append("pos_y.png").c_str(),
		p4.append("neg_y.png").c_str(),
		p5.append("pos_z.png").c_str(),
		p6.append("neg_z.png").c_str());
}
Пример #20
0
void CTest::x_TestErrCode()
{
    NcbiCout << "Testing ErrCodes\n";

    CNcbiDiag p1( CDiagCompileInfo("", 0, NCBI_CURRENT_FUNCTION) );
    p1.SetErrorCode(-6,-10);
    m_Diags.push_back(&p1);

    CNcbiDiag p2( CDiagCompileInfo("", 0, NCBI_CURRENT_FUNCTION) );
    p2.SetErrorCode(-6,10);
    m_Diags.push_back(&p2);

    CNcbiDiag p3( CDiagCompileInfo("", 0, NCBI_CURRENT_FUNCTION) );
    p3.SetErrorCode(20,1);
    m_Diags.push_back(&p3);

    CNcbiDiag p4( CDiagCompileInfo("", 0, NCBI_CURRENT_FUNCTION) );
    p4.SetErrorCode(21,1);
    m_Diags.push_back(&p4);
 
    CNcbiDiag p5( CDiagCompileInfo("", 0, NCBI_CURRENT_FUNCTION) );
    p5.SetErrorCode(31,21);
    m_Diags.push_back(&p5);

    CNcbiDiag p6( CDiagCompileInfo("", 0, NCBI_CURRENT_FUNCTION) );
    p6.SetErrorCode(40,1);
    m_Diags.push_back(&p6);
   
    {
        int expects[] = { 1, 1, 1, 0, 0, 1 };
        x_TestString("(-10--5,20,30-40.) !(31.1-100)",expects);
    }

    {
        int expects[] = { 1, 0, 0, 1, 1, 0 };
        x_TestString("!(-10--5,20,30-40.1-20)",expects);
    }

    {
        int expects[] = { 1, 0, 0, 1, 1, 0 };
        x_TestString("!(20.) !(30-40.1-20) !(-6.1-100)",expects);
    }
    m_Diags.clear();
}
Пример #21
0
TEST( Orient_Exact3, Test1 ) {

	GeoLib::Point_3 p1(0,0,0), p2(1,0,0), p3(0,1,0),  p4(0,0,1), p5(0,0,-1), p6(2,2,0);

	double dRight = GeoLib::OrientExact_3( p1, p2, p3, p4 );
	EXPECT_TRUE( dRight < 0 );

	double dLeft = GeoLib::OrientExact_3( p1, p2, p3, p5 );
	EXPECT_TRUE( dLeft > 0 );

	double dZero = GeoLib::OrientExact_3( p1, p2, p3, p6 );
	EXPECT_NEAR( 0.0, dZero, 1E-30 );

	double dInvRight = GeoLib::OrientExact_3( p1, p2, p4, p3 );	// swap p3, p4
	EXPECT_TRUE( dInvRight > 0 );

	double dInvLeft = GeoLib::OrientExact_3( p1, p2, p5, p3 );	// swap p3, p5
	EXPECT_TRUE( dInvLeft < 0 );
}
Пример #22
0
int main(int argc, char* argv[]) {
  chain<ReqGenerator, ReqParser, ReqPrinter> p2;
  p2();

  chain<ReqGenerator, ReqParser2, ReqPrinter> p3;
  p3();

  chain<ReqGenerator, ReqParser, ReqParser2, ReqPrinter> p4;
  p4();

  chain<ReqGenerator, ReqParser, ReqPrinter2> p5;
  p5();

  chain<ReqGenerator, ReqParser2, ReqPrinter2> p6;
  p6();

  chain<ReqGenerator, ReqParser3, ReqPrinter2, ReqPrinter3> p7;
  p7();
}
Пример #23
0
/**
 * Load a predefined set of double-click gestures patterns.
 * Theses patterns are manualy recorded @ 20FPS
 * If the framerate changes the patterns wont be relevant anymore.
 */
void DoubleClickFilter::loadDoubleClickPatterns()
{
    cv::Mat p1( sizeof(doubleClickPattern_1)/sizeof(float), 1, CV_32F, doubleClickPattern_1 );
    cv::Mat p2( sizeof(doubleClickPattern_2)/sizeof(float), 1, CV_32F, doubleClickPattern_2 );
    cv::Mat p3( sizeof(doubleClickPattern_3)/sizeof(float), 1, CV_32F, doubleClickPattern_3 );
    cv::Mat p4( sizeof(doubleClickPattern_4)/sizeof(float), 1, CV_32F, doubleClickPattern_4 );
    cv::Mat p5( sizeof(doubleClickPattern_5)/sizeof(float), 1, CV_32F, doubleClickPattern_5 );
    cv::Mat p6( sizeof(doubleClickPattern_6)/sizeof(float), 1, CV_32F, doubleClickPattern_6 );
    cv::Mat p7( sizeof(doubleClickPattern_7)/sizeof(float), 1, CV_32F, doubleClickPattern_7 );
    cv::Mat p8( sizeof(doubleClickPattern_8)/sizeof(float), 1, CV_32F, doubleClickPattern_8 );

    addPattern( p1 );
    addPattern( p2 );
    addPattern( p3 );
    addPattern( p4 );
    addPattern( p5 );
    addPattern( p6 );
    addPattern( p7 );
    addPattern( p8 );
}
Пример #24
0
int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);
    QQmlApplicationEngine engine;

    Player p1("Emma", 4);
    Player p2("Emma", 4);
    Player p3("Emma", 4);
    Player p4("Emma", 4);
    Player p5("Emma", 4);
    Player p6("Emma", 4);
    Player p7("Emma", 4);
    Player p8("Emma", 4);
    Player p9("Emma", 4);
    Player p10("Emma", 4);
    Player p11("Emma", 4);
    Player p12("Emma", 4);
    Match m(3);

    engine.rootContext()->setContextProperty("player1", &p1);
    engine.rootContext()->setContextProperty("player2", &p2);
    engine.rootContext()->setContextProperty("player3", &p3);
    engine.rootContext()->setContextProperty("player4", &p4);
    engine.rootContext()->setContextProperty("player5", &p5);
    engine.rootContext()->setContextProperty("player6", &p6);
    engine.rootContext()->setContextProperty("player7", &p7);
    engine.rootContext()->setContextProperty("player8", &p8);
    engine.rootContext()->setContextProperty("player9", &p9);
    engine.rootContext()->setContextProperty("player10", &p10);
    engine.rootContext()->setContextProperty("player11", &p11);
    engine.rootContext()->setContextProperty("player12", &p12);
    engine.rootContext()->setContextProperty("match", &m);

    QCoreApplication::setApplicationName("Lab2");
    QCoreApplication::setOrganizationName("EMMA");
    QCoreApplication::setOrganizationDomain(".fourThompson");

    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));

    return app.exec();
}
Пример #25
0
int main()
{
    std::pair<int, float> p1;
    std::cout << "Value-initialized: "
              << p1.first << ", " << p1.second << '\n';
 
    std::pair<int, double> p2(42, 0.123);
    std::cout << "Initialized with two values: "
              << p2.first << ", " << p2.second << '\n';
 
    std::pair<char, int> p4(p2);
    std::cout << "Implicitly converted: "
              << p4.first << ", " << p4.second << '\n';
 
    std::pair<std::complex<double>, std::string> p6(
                    std::piecewise_construct, 
                    std::forward_as_tuple(0.123, 7.7),
                    std::forward_as_tuple(10, 'a'));
    std::cout << "Piecewise constructed: "
              << p6.first << ", " << p6.second << '\n';
}
Пример #26
0
void VglPlus::parallelMove(const vgl_line_segment_2d<double> & initSeg, double distance,
                           vgl_line_segment_2d<double> & seg1, vgl_line_segment_2d<double> & seg2)
{
    // CCW rotated
    vgl_vector_2d<double> orthDir = rotated(initSeg.direction(), vnl_math::pi/2.0);
    orthDir = normalize(orthDir);
    
    vgl_point_2d<double> p1 = initSeg.point1();
    vgl_point_2d<double> p2 = initSeg.point2();
    
    vgl_vector_2d<double> dp = distance * orthDir;
    vgl_point_2d<double> p3(p1.x() + dp.x(), p1.y() + dp.y());
    vgl_point_2d<double> p4(p2.x() + dp.x(), p2.y() + dp.y());
    
    seg1 = vgl_line_segment_2d<double>(p3, p4);
    
    dp = -1.0 * dp;
    vgl_point_2d<double> p5(p1.x() + dp.x(), p1.y() + dp.y());
    vgl_point_2d<double> p6(p2.x() + dp.x(), p2.y() + dp.y());
    seg2 = vgl_line_segment_2d<double>(p5, p6);
}
Пример #27
0
std::vector<Triangle> triangulationCube(int rayon){

	std::vector<Triangle> listeTriangle;
	
	
	Point p0(-rayon, rayon, - rayon); //en haut à gauche
	Point p1(rayon, rayon,  - rayon); //en haut à droite
	Point p2(rayon,  - rayon,  - rayon); //en bas à droite
	Point p3(- rayon, - rayon,  - rayon); //en bas à gauche
	
	Point p4( - rayon,  rayon,  rayon);
	Point p5( rayon,  rayon, rayon);
	Point p6( rayon,  - rayon, rayon);
	Point p7( - rayon, - rayon, rayon);
	
	
	listeTriangle.push_back(Triangle(p0,p1,p2));
	listeTriangle.push_back(Triangle(p0,p2,p3));
	
	/*
	listeTriangle.push_back(Triangle(p4,p5,p6));
	listeTriangle.push_back(Triangle(p4,p6,p7));
	
	listeTriangle.push_back(Triangle(p0,p4,p5));
	listeTriangle.push_back(Triangle(p0,p5,p1));
	
	listeTriangle.push_back(Triangle(p1,p5,p6));
	listeTriangle.push_back(Triangle(p1,p6,p2));
	
	listeTriangle.push_back(Triangle(p6,p2,p3));
	listeTriangle.push_back(Triangle(p6,p3,p7));
	
	listeTriangle.push_back(Triangle(p0,p4,p7));
	listeTriangle.push_back(Triangle(p0,p7,p3));
*/

	return listeTriangle;

}
Пример #28
0
void setup(MeshType & mesh, viennagrid::hexahedron_tag)
{
  typedef typename viennagrid::result_of::point<MeshType>::type               PointType;
  typedef typename viennagrid::result_of::vertex_handle<MeshType>::type       VertexHandleType;

  PointType p0(0.0, 0.0, 0.0);
  PointType p1(1.0, 0.0, 0.0);
  PointType p2(1.0, 1.0, 0.0);
  PointType p3(0.0, 1.0, 0.0);
  PointType p4(0.0, 0.0, 1.0);
  PointType p5(1.0, 0.0, 1.0);
  PointType p6(1.0, 1.0, 1.0);
  PointType p7(0.0, 1.0, 1.0);
  PointType p8(2.0, 0.0, 0.0);
  PointType p9(2.0, 1.0, 0.0);
  PointType p10(2.0, 0.0, 1.0);
  PointType p11(2.0, 1.0, 1.0);

  std::cout << "Adding vertices to segment:" << std::endl;


  VertexHandleType vh0 = viennagrid::make_vertex( mesh, p0 );
  VertexHandleType vh1 = viennagrid::make_vertex( mesh, p1 );
  VertexHandleType vh2 = viennagrid::make_vertex( mesh, p2 );
  VertexHandleType vh3 = viennagrid::make_vertex( mesh, p3 );
  VertexHandleType vh4 = viennagrid::make_vertex( mesh, p4 );
  VertexHandleType vh5 = viennagrid::make_vertex( mesh, p5 );
  VertexHandleType vh6 = viennagrid::make_vertex( mesh, p6 );
  VertexHandleType vh7 = viennagrid::make_vertex( mesh, p7 );
  VertexHandleType vh8 = viennagrid::make_vertex( mesh, p8 );
  VertexHandleType vh9 = viennagrid::make_vertex( mesh, p9 );
  VertexHandleType vh10 = viennagrid::make_vertex( mesh, p10 );
  VertexHandleType vh11 = viennagrid::make_vertex( mesh, p11 );


  viennagrid::make_hexahedron( mesh, vh0, vh1, vh3, vh2, vh4, vh5, vh7, vh6 );
  viennagrid::make_hexahedron( mesh, vh1, vh8, vh2, vh9, vh5, vh10, vh6, vh11 );
}
Пример #29
0
void GfxMesh::addCube(float _size, Vec3f _pos, Vec4f _color, bool _front, bool _back, bool _right, bool _left, bool _top, bool _bottom)
{
	_size /= 2.0f;

	Vec3f p0(_pos.x - _size, _pos.y - _size, _pos.z + _size);
	Vec3f p1(_pos.x + _size, _pos.y - _size, _pos.z + _size);
	Vec3f p2(_pos.x + _size, _pos.y + _size, _pos.z + _size);
	Vec3f p3(_pos.x - _size, _pos.y + _size, _pos.z + _size);
	Vec3f p4(_pos.x + _size, _pos.y - _size, _pos.z - _size);
	Vec3f p5(_pos.x - _size, _pos.y - _size, _pos.z - _size);
	Vec3f p6(_pos.x - _size, _pos.y + _size, _pos.z - _size);
	Vec3f p7(_pos.x + _size, _pos.y + _size, _pos.z - _size);

	Vec3f n;

	unsigned int v0, v1, v2, v3, v4, v5, v6, v7;

	// Front
	if (_front)
	{
		n = Vec3f(0.0f, 0.0f, 1.0f);

		v0 = addVertex(p0, n, _color);
		v1 = addVertex(p1, n, _color);
		v2 = addVertex(p2, n, _color);
		v3 = addVertex(p3, n, _color);

		addTriangle(v0, v1, v2);
		addTriangle(v0, v2, v3);
	}

	// Back
	if (_back)
	{
		n = Vec3f(0.0f, 0.0f, -1.0f);

		v4 = addVertex(p4, n, _color);
		v5 = addVertex(p5, n, _color);
		v6 = addVertex(p6, n, _color);
		v7 = addVertex(p7, n, _color);

		addTriangle(v4, v5, v6);
		addTriangle(v4, v6, v7);
	}

	// Right
	if (_right)
	{
		n = Vec3f(1.0f, 0.0f, 0.0f);

		v1 = addVertex(p1, n, _color);
		v4 = addVertex(p4, n, _color);
		v7 = addVertex(p7, n, _color);
		v2 = addVertex(p2, n, _color);

		addTriangle(v1, v4, v7);
		addTriangle(v1, v7, v2);
	}

	// Left
	if (_left)
	{
		n = Vec3f(-1.0f, 0.0f, 0.0f);

		v5 = addVertex(p5, n, _color);
		v0 = addVertex(p0, n, _color);
		v3 = addVertex(p3, n, _color);
		v6 = addVertex(p6, n, _color);

		addTriangle(v5, v0, v3);
		addTriangle(v5, v3, v6);
	}

	// Top
	if (_top)
	{
		n = Vec3f(0.0f, 1.0f, 0.0f);

		v3 = addVertex(p3, n, _color);
		v2 = addVertex(p2, n, _color);
		v7 = addVertex(p7, n, _color);
		v6 = addVertex(p6, n, _color);

		addTriangle(v3, v2, v7);
		addTriangle(v3, v7, v6);
	}

	// Bottom
	if (_bottom)
	{
		n = Vec3f(0.0f, -1.0f, 0.0f);

		v5 = addVertex(p5, n, _color);
		v4 = addVertex(p4, n, _color);
		v1 = addVertex(p1, n, _color);
		v0 = addVertex(p0, n, _color);

		addTriangle(v5, v4, v1);
		addTriangle(v5, v1, v0);
	}
}
Пример #30
0
bool UniformGrid::intersectsCell(const Model& model, const CellCoord& coord) {
  // Left side
  // Bottom left point
  Point3D p0 = pointAt(coord);
  Point3D p1(p0[0], p0[1] + cellSize, p0[2]);
  Point3D p2(p0[0], p0[1] + cellSize, p0[2] + cellSize);
  Point3D p3(p0[0], p0[1], p0[2] + cellSize);

  // Right side
  Point3D p4(p0[0] + cellSize, p0[1], p0[2]);
  Point3D p5(p0[0] + cellSize, p0[1] + cellSize, p0[2]);
  Point3D p6(p0[0] + cellSize, p0[1] + cellSize, p0[2] + cellSize);
  Point3D p7(p0[0] + cellSize, p0[1], p0[2] + cellSize);

  const std::vector<Point3D> pts = {p0, p1, p2, p3, p4, p5, p6, p7};

  auto cellMat = translationMatrix(p0[0], p0[1], p0[2]) * cellSizeScaleMatrix;
  // But we need the inverse of course
  cellMat = cellMat.invert();

  // Check if a pt is in the cell
  auto inCell = [&] (const Point3D& pt) -> bool {
    return p0[0] <= pt[0] && pt[0] <= (p0[0] + cellSize) &&
           p0[1] <= pt[1] && pt[1] <= (p0[1] + cellSize) &&
           p0[2] <= pt[2] && pt[2] <= (p0[2] + cellSize);
  };

  // First, we need to get the 8 points of the bounding box
  auto bbox = model.getBoundingBox();

  auto inBoundingBox = [&bbox] (const Point3D& pt) -> bool {
    // We are in the box if we are in between all the opposite parallel planes
    const auto c1 = bbox[0]; // Bottom back left corner
    const auto v1a = bbox[1] - c1; // Bottom back left to bottom back right
    const auto v1b = bbox[3] - c1; // Bottom back left to top back left
    const auto v1c = bbox[4] - c1; // Bottom back left to bottom front left
    const auto n1 = v1a.cross(v1b); // Back face
    const auto n2 = v1b.cross(v1c); // Left face
    const auto n3 = v1c.cross(v1a); // Bottom face

    const auto c2 = bbox[6]; // Top front right corner
    const auto v2a = bbox[5] - c2; // Top front right to bottom front right
    const auto v2b = bbox[7] - c2; // Top front right to top front left
    const auto v2c = bbox[2] - c2; // Top front right to top back right
    // We want this to be opposite sign (i.e. not pointing inwards)
    // so we do the opposite cross as above
    const auto n4 = v2b.cross(v2a); // Front face
    const auto n5 = v2c.cross(v2b); // Top face
    const auto n6 = v2a.cross(v2c); // Right face

    return betweenPlanes(n1, c1, n4, c2, pt) &&
           betweenPlanes(n2, c1, n6, c2, pt) &&
           betweenPlanes(n3, c1, n5, c2, pt);
  };

  // A corner of the bbox being inside the cell implies an intersection
  // between the bbox and the cell.
  for (const auto& pt : bbox) {
    if (inCell(pt)) {
      return true;
    }
  }

  // Similarly, a corner of cell inside bbox implies intersection
  for (const auto& pt : pts) {
    if (inBoundingBox(pt)) {
      return true;
    }
  }

  // Check if any of the 12 lines from bbox intersect this cell
  HitRecord hr;
  for (size_t i = 0; i < 8; ++i) {
    // This is the vector of one edge
    Vector3D v = bbox[(i % 4 == 0) ? i + 3 : i - 1] - bbox[i];
    Ray ray(bbox[i] - v, bbox[i]);
    if (utilityCube.intersects(ray, &hr, cellMat) && 1 <= hr.t && hr.t <= 2) {
      // This edge of the bounding box intersects our cell cube.
      return true;
    }
  }
  for (size_t i = 0; i < 4; ++i) {
    Vector3D v = bbox[i + 4] - bbox[i];
    Ray ray(bbox[i] - v, bbox[i]);
    if (utilityCube.intersects(ray, &hr, cellMat) && 1 <= hr.t && hr.t <= 2) {
      // This edge of the bounding box intersects our cell cube.
      return true;
    }
  }

  // Now check if any of the 12 lines from this cell intersect the model
  for (size_t i = 0; i < pts.size(); ++i) {
    Vector3D v = pts[(i % 4 == 0) ? i + 3 : i - 1] - pts[i];
    // Note: We are doing pts[i] - v and checking for t between 1 and 2.
    // This is equivalent to checking between 0 and 1 without doing the
    // subtraction, *but* we have an epsilon check in the intersects code.
    // For this case, we do *not* want to bother with epsilon check, so we
    // will check from 1 to 2 to avoid it.
    if (model.intersects(Ray(pts[i] - v, pts[i]), &hr)) {
      if (1 <= hr.t && hr.t <= 2) {
        return true;
      }
    }
  }

  // Now we have to check the struts between the two sides
  for (size_t i = 0; i < 4; ++i) {
    Vector3D v = pts[i + 4] - pts[i];
    if (model.intersects(Ray(pts[i] - v, pts[i]), &hr)) {
      if (1 <= hr.t && hr.t <= 2) {
        return true;
      }
    }
  }

  return false;
}