//Begin TriangleGen
void TriangleGen::generator(const color4& color0, const color4& color1, const color4& color2) {
	//set vertices
	elements[0] = point4(-sqrt(3.0)/2.0, -0.5, 0.0, 1.0);
	elements[1] = point4(sqrt(3.0)/2.0, -0.5, 0.0, 1.0);
	elements[2] = point4(0.0, 1.0, 0.0, 1.0);
	//set colors
	elements[3] = color0; elements[4] = color1; elements[5] = color2;
	//set normals
	elements[6] = MatMath::zNORM; elements[7] = -MatMath::zNORM;

	//front triangle
	data[0] = elements[0]; data[1] = elements[1]; data[2] = elements[2];
	//back triangle
	data[3] = elements[2]; data[4] = elements[1]; data[5] = elements[0];
	//front colors
	data[6] = elements[3]; data[7] = elements[4]; data[8] = elements[5];
	//back colors
	data[9] = elements[5]; data[10] = elements[4]; data[11] = elements[3];
	//front normals
	data[12] = data[13] = data[14] = elements[6];
	//back normals
	data[15] = data[16] = data[17] = elements[7];

	//front indices
	indices[0] = 0; indices[1] = 1; indices[2] = 2;
	//back indices
	indices[3] = 3; indices[4] = 4; indices[5] = 5;
}
//SquareGen
void SquareGen::generate(	const color4& color0, const color4& color1,
							const color4& color2, const color4& color3	)
{
	//set vertices
	elements[0] = point4(-1.0, -1.0, 0.0, 1.0); elements[1] = point4(1.0, -1.0, 0.0, 1.0);
	elements[2] = point4(1.0, 1.0, 0.0, 1.0); elements[3] = point4(-1.0, 1.0, 0.0, 1.0);
	//set colors
	elements[4] = color0; elements[5] = color1; elements[6] = color2; elements[7] = color3;
	//set normals
	elements[8] = MatMath::zNORM; elements[9] = -MatMath::zNORM;

	//front square
	data[0] = elements[0]; data[1] = elements[1]; data[2] = elements[2]; data[3] = elements[3];
	//back square
	data[4] = elements[3]; data[5] = elements[2]; data[6] = elements[1]; data[7] = elements[0];
	//front colors
	data[8] = elements[4]; data[9] = elements[5]; data[10] = elements[6]; data[11] = elements[7];
	//back colors
	data[12] = elements[7]; data[13] = elements[6]; data[14] = elements[5]; data[15] = elements[4];
	//front normals
	data[16] = data[17] = data[18] = data[19] = elements[8];
	//back normals
	data[20] = data[21] = data[22] = data[23] = elements[9];

	//front triangles
	indices[0] = 0; indices[1] = 1; indices[2] = 2;
	indices[3] = 0; indices[4] = 2; indices[5] = 3;
	//back triangles
	indices[6] = 4; indices[7] = 5; indices[8] = 6;
	indices[9] = 4; indices[10] = 6; indices[11] = 7;
}
Beispiel #3
0
vec4*   Geometry::createUnitTriangle(){
    int i = 0;
    vec4* ret = new vec4[3];
    ret[i] = point4( -U_CUBE_C, -U_CUBE_C,  U_CUBE_C, 1.0 ); i++;
    ret[i] = point4(         0,  U_CUBE_C,  U_CUBE_C, 1.0 ); i++;
    ret[i] = point4(  U_CUBE_C,  -U_CUBE_C,  U_CUBE_C, 1.0 );
    return ret;
}
Beispiel #4
0
vec4*   Geometry::createUnitPlane(){
    int i = 0;
    vec4 * ret = new vec4[4];
    ret[i] = point4( -U_CUBE_C, -U_CUBE_C,  U_CUBE_C, 1.0 ); i++;
    ret[i] = point4( -U_CUBE_C,  U_CUBE_C,  U_CUBE_C, 1.0 ); i++;
    ret[i] = point4(  U_CUBE_C,  U_CUBE_C,  U_CUBE_C, 1.0 ); i++;
    ret[i] = point4(  U_CUBE_C, -U_CUBE_C,  U_CUBE_C, 1.0 );
    return ret;
}
Beispiel #5
0
void poly4::makePoints3() {
	if (points4.size() == 0){
		std::cout << "Error: poly4::makePoints3 called with empty points4. " << std::endl;
		exit(1);
	}
	
	if (projVec.isZero()){
		std::cout << "poly4::makePoints3() requires a projection vector" <<std::endl;
		exit(1);
	}
		
		//	std::cout << "projVec = " << projVec << std::endl;
	
	basis[0] = point4(1.,0.,0.,0.);
	basis[0] -= (basis[0]*projVec) * projVec;
	if (basis[0].isZero()){
		basis[0] = point4(0.,1.,0.,0.);
		basis[0] -= (basis[0]*projVec) * projVec;
		if (basis[0].isZero()){
			std::cout << " problem with isZero()??? " << std::endl;
			exit(1);
		}
	}
	basis[0].makeUnit();
	
	basis[1] = point4(0.,0.,1.,0.);
		//	std::cout << (basis[1]*projVec)* projVec << " " <<  (basis[1]*basis[0])*basis[0] << std::endl;
	basis[1] -= (basis[1]*projVec) * projVec;
		//	std::cout << basis[1] << " : " << basis[1]*basis[0] << " " << basis[1]*projVec << std::endl;
	basis[1] -= (basis[1]*basis[0])*basis[0];
	
	if (basis[1].isZero()){
		basis[1] = point4(0.,0.,0.,1.);
		basis[1] -= (basis[1]*projVec)* projVec;
		basis[1] -= (basis[1]*basis[0])*basis[0];
		if (basis[1].isZero()){
				// std::cout << " problem with isZero()??? " << std::endl;
			exit(1);
		}
	}
	basis[1].makeUnit();
		//	std::cout << basis[1]*basis[0] << " " << basis[1]*projVec << std::endl;
	
	basis[2] = projVec.cross(basis[0],basis[1]);
	basis[2].makeUnit();
	
		//	std::cout << "basis : " << basis[0] << " " << basis[1] << " " << basis[2] << std::endl;
	
		// check orthogonality??
	
	for (int i=0;i<points4.size();i++) 
		points.push_back( point(basis[0]*points4[i],basis[1]*points4[i],basis[2]*points4[i]));

		//	for (int i=0;i<points.size();i++)
		//		std::cout << "p["<< i << "] : " << points[i] << std::endl;
}
Beispiel #6
0
CCube::CCube(double size, bool drawFrontFace)
{
	// Vertices of a unit cube centered at origin, sides aligned with axes
	vertex_positions[0] = point4( -size, -size,  size, 1.0 );
	vertex_positions[1] = point4( -size,  size,  size, 1.0 );
	vertex_positions[2] = point4(  size,  size,  size, 1.0 );
	vertex_positions[3] = point4(  size, -size,  size, 1.0 );
	vertex_positions[4] = point4( -size, -size, -size, 1.0 );
	vertex_positions[5] = point4( -size,  size, -size, 1.0 );
	vertex_positions[6] = point4(  size,  size, -size, 1.0 );
	vertex_positions[7] = point4(  size, -size, -size, 1.0 );


	int Index = 0;
	if(drawFrontFace)
	{
		quad( 1, 0, 3, 2 , vertex_positions, Index);
	}
	quad( 2, 3, 7, 6 ,  vertex_positions, Index);
	quad( 3, 0, 4, 7 ,  vertex_positions, Index);
	quad( 6, 5, 1, 2 ,  vertex_positions, Index);
	quad( 4, 5, 6, 7 ,  vertex_positions, Index);
	quad( 5, 4, 0, 1 ,  vertex_positions, Index);

	//Initialize the motion
	v = vec3(15.0, 0., 0.);
	w = vec3(1., 1., 1.);
}
Beispiel #7
0
void Terrain::addTriangle(point4 p1, point4 p2, point4 p3, color4 high, color4 mid, color4 low, color4 brown){

    point4 p1_new = point4(p1.x, p1.y, POSITIVE(p1.z), p1.w);
    point4 p2_new = point4(p2.x, p2.y, POSITIVE(p2.z), p2.w);
    point4 p3_new = point4(p3.x, p3.y, POSITIVE(p3.z), p3.w);
    vec4 u = p2_new - p1_new;
    vec4 v = p3_new - p1_new;
    vec3 normal = -normalize( cross(u, v) );

    if (this->points.size() < this->num_points + 5){
        this->points.resize(2*this->points.size());
        this->normals.resize(2*this->points.size());
        this->colors.resize(2*this->points.size());
    }

    points[this->num_points] = p1_new;
    normals[this->num_points] = normal;
    if (p1.z == 0){
        colors[this->num_points++] = low;
    } else if (p1.z > -0.5*this->range){
        colors[this->num_points++] = mid;
    } else if (p1.z > -0.75*this->range){
        colors[this->num_points++] = brown;
    } else {
        colors[this->num_points++] = high;
    }
    points[this->num_points] = p2_new;
    normals[this->num_points] = normal;
    if (p2.z == 0){
        colors[this->num_points++] = low;
    } else if (p2.z > -0.5*this->range){
        colors[this->num_points++] = mid;
    } else if (p3.z > -0.75*this->range){
        colors[this->num_points++] = brown;
    } else {
        colors[this->num_points++] = high;
    }
    points[this->num_points] = p3_new;
    normals[this->num_points] = normal;
    if (p3.z == 0){
        colors[this->num_points++] = low;
    } else if (p3.z > -0.5*this->range){
        colors[this->num_points++] = mid;
    } else if (p3.z > -0.75*this->range){
        colors[this->num_points++] = brown;
    } else {
        colors[this->num_points++] = high;
    }
}
  void TestOpDeselectPoint()
  {
    //check OpDESELECTPOINT  ExecuteOperation
    mitk::Point3D point4(0.);

    doOp = new mitk::PointOperation(mitk::OpDESELECTPOINT, point4,4);

    pointSet->ExecuteOperation(doOp);

    CPPUNIT_ASSERT_EQUAL_MESSAGE("check PointOperation OpDESELECTPOINT ",
        false, pointSet->GetSelectInfo(4));
    CPPUNIT_ASSERT_EQUAL_MESSAGE("check GetNumeberOfSelected ",
        true, pointSet->GetNumberOfSelected() == 0 );

    /*
    if (pointSet->GetSelectInfo(4))
    {
    std::cout<<"[FAILED]"<<std::endl;
    return EXIT_FAILURE;
    }
    delete doOp;
    std::cout<<"[PASSED]"<<std::endl;


    if(pointSet->GetNumberOfSelected() != 0)
    {
    std::cout<<"[FAILED]"<<std::endl;
    return EXIT_FAILURE;
    }
    std::cout<<"[PASSED]"<<std::endl;
     */
  }
void MyPrimitive::GenerateTube(float a_fOuterRadius, float a_fInnerRadius, float a_fHeight, int a_nSubdivisions, vector3 a_v3Color)
{
	if (a_nSubdivisions < 3)
		a_nSubdivisions = 3;
	if (a_nSubdivisions > 360)
		a_nSubdivisions = 360;

	Release();
	Init();

	for (int i = 0; i < a_nSubdivisions; i++)
	{
		float ang = (2 * PI) / a_nSubdivisions;

		vector3 point0(a_fOuterRadius*cos((i + 1)*ang), a_fHeight, a_fOuterRadius*sin((i + 1)*ang)); //1
		vector3 point1(a_fOuterRadius*cos(i*ang), 0, a_fOuterRadius*sin(i*ang)); //2
		vector3 point2(a_fOuterRadius*cos(i*ang), a_fHeight, a_fOuterRadius*sin(i*ang)); //0
		vector3 point3(a_fOuterRadius*cos((i + 1)*ang), 0, a_fOuterRadius*sin((i + 1)*ang)); //3

		vector3 point4(a_fInnerRadius*cos((i + 1)*ang), a_fHeight, a_fInnerRadius*sin((i + 1)*ang)); //1
		vector3 point5(a_fInnerRadius*cos(i*ang), 0, a_fInnerRadius*sin(i*ang)); //2
		vector3 point6(a_fInnerRadius*cos(i*ang), a_fHeight, a_fInnerRadius*sin(i*ang)); //0
		vector3 point7(a_fInnerRadius*cos((i + 1)*ang), 0, a_fInnerRadius*sin((i + 1)*ang)); //3

		AddQuad(point4, point0, point6, point2); //Top
		AddQuad(point0, point3, point2, point1); //Outer
		AddQuad(point7, point5, point3, point1); //Bottom
		AddQuad(point5, point7, point6,point4 ); // Inner
		
	}

	//Your code ends here
	CompileObject(a_v3Color);
}
Beispiel #10
0
BaseIF* makeVane(const Real&     thick,
                 const RealVect& normal,
                 const Real&     innerRadius,
                 const Real&     outerRadius,
                 const Real&     offset,
                 const Real&     height)
{
  RealVect zero(D_DECL(0.0,0.0,0.0));
  RealVect xAxis(D_DECL(1.0,0.0,0.0));
  bool inside = true;

  Vector<BaseIF*> vaneParts;

  // Each side of the vane (infinite)
  RealVect normal1(normal);
  RealVect point1(D_DECL(offset+height/2.0,-thick/2.0,0.0));
  PlaneIF plane1(normal1,point1,inside);

  vaneParts.push_back(&plane1);

  RealVect normal2(-normal);
  RealVect point2(D_DECL(offset+height/2.0,thick/2.0,0.0));
  PlaneIF plane2(normal2,point2,inside);

  vaneParts.push_back(&plane2);

  // Make sure we only get something to the right of the origin
  RealVect normal3(D_DECL(0.0,0.0,1.0));
  RealVect point3(D_DECL(0.0,0.0,0.0));
  PlaneIF plane3(normal3,point3,inside);

  vaneParts.push_back(&plane3);

  // Cut off the top and bottom
  RealVect normal4(D_DECL(1.0,0.0,0.0));
  RealVect point4(D_DECL(offset,0.0,0.0));
  PlaneIF plane4(normal4,point4,inside);

  vaneParts.push_back(&plane4);

  RealVect normal5(D_DECL(-1.0,0.0,0.0));
  RealVect point5(D_DECL(offset+height,0.0,0.0));
  PlaneIF plane5(normal5,point5,inside);

  vaneParts.push_back(&plane5);

  // The outside of the inner cylinder
  TiltedCylinderIF inner(innerRadius,xAxis,zero,!inside);

  vaneParts.push_back(&inner);

  // The inside of the outer cylinder
  TiltedCylinderIF outer(outerRadius,xAxis,zero,inside);

  vaneParts.push_back(&outer);

  IntersectionIF* vane = new IntersectionIF(vaneParts);

  return vane;
}
  void TestOpMovePointUp()
  {
    //check OpMOVEPOINTUP  ExecuteOperation
    const int id = 4;

    mitk::Point3D point = pointSet->GetPoint(id);

    mitk::Point3D point4(0.);
    doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP, point4, id);

    pointSet->ExecuteOperation(doOp);
    mitk::Point3D tempPoint = pointSet->GetPoint(id-1);

    CPPUNIT_ASSERT_EQUAL_MESSAGE("check PointOperation OpMOVEPOINTUP ",
        true, tempPoint == point);

    /*
    if (tempPoint != point)
    {
    std::cout<<"[FAILED]"<<std::endl;
    return EXIT_FAILURE;
    }
    delete doOp;
    std::cout<<"[PASSED]"<<std::endl;
     */
  }
void Rectangle3DOverlay::render(RenderArgs* args) {
    if (!_visible) {
        return; // do nothing if we're not visible
    }

    float alpha = getAlpha();
    xColor color = getColor();
    const float MAX_COLOR = 255.0f;
    glm::vec4 rectangleColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);

    glm::vec3 position = getPosition();
    glm::vec2 dimensions = getDimensions();
    glm::vec2 halfDimensions = dimensions * 0.5f;
    glm::quat rotation = getRotation();

    auto batch = args->_batch;

    if (batch) {
        Transform transform;
        transform.setTranslation(position);
        transform.setRotation(rotation);

        batch->setModelTransform(transform);
        auto geometryCache = DependencyManager::get<GeometryCache>();

        if (getIsSolid()) {
            glm::vec3 topLeft(-halfDimensions.x, -halfDimensions.y, 0.0f);
            glm::vec3 bottomRight(halfDimensions.x, halfDimensions.y, 0.0f);
            geometryCache->bindSimpleProgram(*batch);
            geometryCache->renderQuad(*batch, topLeft, bottomRight, rectangleColor);
        } else {
            geometryCache->bindSimpleProgram(*batch, false, false, false, true, true);
            if (getIsDashedLine()) {
                glm::vec3 point1(-halfDimensions.x, -halfDimensions.y, 0.0f);
                glm::vec3 point2(halfDimensions.x, -halfDimensions.y, 0.0f);
                glm::vec3 point3(halfDimensions.x, halfDimensions.y, 0.0f);
                glm::vec3 point4(-halfDimensions.x, halfDimensions.y, 0.0f);

                geometryCache->renderDashedLine(*batch, point1, point2, rectangleColor);
                geometryCache->renderDashedLine(*batch, point2, point3, rectangleColor);
                geometryCache->renderDashedLine(*batch, point3, point4, rectangleColor);
                geometryCache->renderDashedLine(*batch, point4, point1, rectangleColor);
            } else {
                if (halfDimensions != _previousHalfDimensions) {
                    QVector<glm::vec3> border;
                    border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);
                    border << glm::vec3(halfDimensions.x, -halfDimensions.y, 0.0f);
                    border << glm::vec3(halfDimensions.x, halfDimensions.y, 0.0f);
                    border << glm::vec3(-halfDimensions.x, halfDimensions.y, 0.0f);
                    border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);
                    geometryCache->updateVertices(_geometryCacheID, border, rectangleColor);

                    _previousHalfDimensions = halfDimensions;
                }
                geometryCache->renderVertices(*batch, gpu::LINE_STRIP, _geometryCacheID);
            }
        }
    }
}
	// out: optimized model-shape
	// in: GRAY img
	// in: evtl zusaetzlicher param um scale-level/iter auszuwaehlen
	// calculates shape updates (deltaShape) for one or more iter/scales and returns...
	// assume we get a col-vec.
	cv::Mat optimize(cv::Mat modelShape, cv::Mat image) {

		for (int cascadeStep = 0; cascadeStep < model.getNumCascadeSteps(); ++cascadeStep) {
			//feature_current = obtain_features(double(TestImg), New_Shape, 'HOG', hogScale);

			vector<cv::Point2f> points;
			for (int i = 0; i < model.getNumLandmarks(); ++i) { // in case of HOG, need integers?
				points.emplace_back(cv::Point2f(modelShape.at<float>(i), modelShape.at<float>(i + model.getNumLandmarks())));
			}
			Mat currentFeatures;
			double dynamicFaceSizeDistance = 0.0;
			if (true) { // adaptive
				// dynamic face-size:
				cv::Vec2f point1(modelShape.at<float>(8), modelShape.at<float>(8 + model.getNumLandmarks())); // reye_ic
				cv::Vec2f point2(modelShape.at<float>(9), modelShape.at<float>(9 + model.getNumLandmarks())); // leye_ic
				cv::Vec2f anchor1 = (point1 + point2) / 2.0f;
				cv::Vec2f point3(modelShape.at<float>(11), modelShape.at<float>(11 + model.getNumLandmarks())); // rmouth_oc
				cv::Vec2f point4(modelShape.at<float>(12), modelShape.at<float>(12 + model.getNumLandmarks())); // lmouth_oc
				cv::Vec2f anchor2 = (point3 + point4) / 2.0f;
				// dynamic window-size:
				// From the paper: patch size $ S_p(d) $ of the d-th regressor is $ S_p(d) = S_f / ( K * (1 + e^(d-D)) ) $
				// D = numCascades (e.g. D=5, d goes from 1 to 5 (Matlab convention))
				// K = fixed value for shrinking
				// S_f = the size of the face estimated from the previous updated shape s^(d-1).
				// For S_f, can use the IED, EMD, or max(IED, EMD). We use the EMD.
				dynamicFaceSizeDistance = cv::norm(anchor1 - anchor2);
				double windowSize = dynamicFaceSizeDistance / 2.0; // shrink value
				double windowSizeHalf = windowSize / 2.0;
				windowSizeHalf = std::round(windowSizeHalf * (1 / (1 + exp((cascadeStep + 1) - model.getNumCascadeSteps())))); // this is (step - numStages), numStages is 5 and step goes from 1 to 5. Because our step goes from 0 to 4, we add 1.
				int NUM_CELL = 3; // think about if this should go in the descriptorExtractor or not. Is it Hog specific?
				int windowSizeHalfi = static_cast<int>(windowSizeHalf) + NUM_CELL - (static_cast<int>(windowSizeHalf) % NUM_CELL); // make sure it's divisible by 3. However, this is not needed and not a good way
				
				currentFeatures = model.getDescriptorExtractor(cascadeStep)->getDescriptors(image, points, windowSizeHalfi);
			}
			else { // non-adaptive, the descriptorExtractor has all necessary params
				currentFeatures = model.getDescriptorExtractor(cascadeStep)->getDescriptors(image, points);
			}
			currentFeatures = currentFeatures.reshape(0, currentFeatures.cols * model.getNumLandmarks()).t();

			//delta_shape = AAM.RF(1).Regressor(hogScale).A(1:end - 1, : )' * feature_current + AAM.RF(1).Regressor(hogScale).A(end,:)';
			Mat regressorData = model.getRegressorData(cascadeStep);
			//Mat deltaShape = regressorData.rowRange(0, regressorData.rows - 1).t() * currentFeatures + regressorData.row(regressorData.rows - 1).t();
			Mat deltaShape = currentFeatures * regressorData.rowRange(0, regressorData.rows - 1) + regressorData.row(regressorData.rows - 1);
			if (true) { // adaptive
				modelShape = modelShape + deltaShape.t() * dynamicFaceSizeDistance;
			}
			else {
				modelShape = modelShape + deltaShape.t();
			}
			
			/*
			for (int i = 0; i < m.getNumLandmarks(); ++i) {
			cv::circle(landmarksImage, Point2f(modelShape.at<float>(i, 0), modelShape.at<float>(i + m.getNumLandmarks(), 0)), 6 - hogScale, Scalar(51.0f*(float)hogScale, 51.0f*(float)hogScale, 0.0f));
			}*/
		}

		return modelShape;
	};
Beispiel #14
0
void Terrain::storePointsTriangles(){
    int i,j,k=0;
    float init_scale_factor = 0.5;
    int center_factor = (this->side_size-1)/2;
    for (i=0; i<this->side_size-1; i++){
        for (j=0; j<this->side_size-1; j++){
            point4 p1 = point4(i-center_factor,j-center_factor,terrain[i][j],1.0);
            point4 p2 = point4(i-center_factor,j+1-center_factor,terrain[i][j+1],1.0);
            point4 p3 = point4(i+1-center_factor,j+1-center_factor,terrain[i+1][j+1],1.0);
            point4 p4 = point4(i+1-center_factor,j-center_factor,terrain[i+1][j],1.0);
            color4 high = color4(.95f, .95f, .95f, 1.0); // White
            color4 mid = color4(.05f, .75f, .45f, 1.0); // Green
            color4 low = color4(.05f, .05f, .95f, 1.0); // Blue
            color4 brown = color4(0.5f, 0.35f, 0.05f, 1.0); // Brown

            addTriangle(p1, p2, p3, high, mid, low, brown);
            addTriangle(p1, p3, p4, high, mid, low, brown);
        }
    }
}
Beispiel #15
0
void TestSnapStrategy::testSquareDistanceToLine()
{
    BoundingBoxSnapStrategy toTestOne;

    const QPointF lineA(4,1);
    const QPointF lineB(6,3);
    const QPointF point(5,8);
    QPointF pointOnLine(0,0);

    qreal result = toTestOne.squareDistanceToLine(lineA, lineB, point, pointOnLine);
    //Should be HUGE_VAL because scalar > diffLength
    QVERIFY(result == HUGE_VAL);

    BoundingBoxSnapStrategy toTestTwo;
    QPointF lineA2(4,4);
    QPointF lineB2(4,4);
    QPointF point2(5,8);
    QPointF pointOnLine2(0,0);

    qreal result2 = toTestTwo.squareDistanceToLine(lineA2, lineB2, point2, pointOnLine2);
    //Should be HUGE_VAL because lineA2 == lineB2
    QVERIFY(result2 == HUGE_VAL);

    BoundingBoxSnapStrategy toTestThree;
    QPointF lineA3(6,4);
    QPointF lineB3(8,6);
    QPointF point3(2,2);
    QPointF pointOnLine3(0,0);

    qreal result3 = toTestThree.squareDistanceToLine(lineA3, lineB3, point3, pointOnLine3);
    //Should be HUGE_VAL because scalar < 0.0
    QVERIFY(result3 == HUGE_VAL);

    BoundingBoxSnapStrategy toTestFour;
    QPointF lineA4(2,2);
    QPointF lineB4(8,6);
    QPointF point4(3,4);
    QPointF pointOnLine4(0,0);

    QPointF diff(6,4);
    //diff = lineB3 - point3 = 6,4
    //diffLength = sqrt(52)
    //scalar = (1*(6/sqrt(52)) + 2*(4/sqrt(52)));

    //pointOnLine = lineA + scalar / diffLength * diff;  lineA + ((1*(6/sqrt(52)) + 2*(4/sqrt(52))) / sqrt(52)) * 6,4;
    QPointF distToPointOnLine = (lineA4 + ((1*(6/sqrt(52.0)) + 2*(4/sqrt(52.0))) / sqrt(52.0)) * diff)-point4;
    qreal toCompWithFour = distToPointOnLine.x()*distToPointOnLine.x()+distToPointOnLine.y()*distToPointOnLine.y();

    qreal result4 = toTestFour.squareDistanceToLine(lineA4, lineB4, point4, pointOnLine4);
    //Normal case with example data
    QVERIFY(qFuzzyCompare(result4, toCompWithFour));

}
Beispiel #16
0
/*
 * Gets the (x, y) position on the screen of the given 3D point.
 * * The coordinates are in the range [0, 1], with the origin in the top left
 * corner. The x-axis is width of the screen, and y-axis is the height.
 *
 * Input:
 *   point: The 3D point whose screen position we want.
 *   camera: The camera we're looking from.
 *
 * Output:
 *   screen_x: The x position of the point on the screen.
 *   screen_y: The y position of the point on the screen.
 */
void VisibilityChecker::GetScreenPosition(const Ogre::Vector3& point,
                                          float* screen_x, float* screen_y) {
  // This projection returns x and y in the range of [-1, 1]. The (-1, -1) point
  // is in the bottom left corner.
  Ogre::Vector4 point4(point.x, point.y, point.z, 1);
  Ogre::Vector4 projected = camera_->getProjectionMatrix()
      * camera_->getViewMatrix() * point4;
  projected = projected / projected.w;

  *screen_x = (projected.x + 1) / 2;
  *screen_y = (1 - projected.y) / 2;
}
Beispiel #17
0
void Terrain::storePointsLines(){
    int i,j,k=0;
    float init_scale_factor = 0.5;
    int center_factor = (this->side_size-1)/2;
    for (i=0; i<this->side_size; i++){
        for (j=0; j<this->side_size-1; j++){
            // Y Line
            points[k] = point4(i-center_factor,j-center_factor,terrain[i][j],1.0);
            colors[k++] = color4(1.0, 1.0, 1.0, 1.0); // White
            points[k] = point4(i-center_factor,j+1-center_factor,terrain[i][j+1],1.0);
            colors[k++] = color4(1.0, 1.0, 1.0, 1.0); // White
            // X Line
            if (i < this->side_size-1){
                points[k] = point4(i-center_factor,j-center_factor,terrain[i][j],1.0);
                colors[k++] = color4(1.0, 1.0, 1.0, 1.0); // White
                points[k] = point4(i+1-center_factor,j-center_factor,terrain[i+1][j],1.0);
                colors[k++] = color4(1.0, 1.0, 1.0, 1.0); // White
            }
        }
        // Final X Line
        if (i < this->side_size-1){
            points[k] = point4((i-center_factor),j-center_factor,terrain[i][j],1.0);
            colors[k++] = color4(1.0, 1.0, 1.0, 1.0); // White
            points[k] = point4(i+1-center_factor,(j-center_factor),terrain[i+1][j],1.0);
            colors[k++] = color4(1.0, 1.0, 1.0, 1.0); // White
        }
    }
    this->num_points = k;
}
Beispiel #18
0
vec4* Geometry::createUnitCube(){
    int i = 0;
    vec4 * vertices = new vec4[8];

    vertices[i] = point4( -U_CUBE_C, -U_CUBE_C,  U_CUBE_C, 1.0 ); i++;
    vertices[i] = point4( -U_CUBE_C,  U_CUBE_C,  U_CUBE_C, 1.0 ); i++;
    vertices[i] = point4(  U_CUBE_C,  U_CUBE_C,  U_CUBE_C, 1.0 ); i++;
    vertices[i] = point4(  U_CUBE_C, -U_CUBE_C,  U_CUBE_C, 1.0 ); i++;
    vertices[i] = point4( -U_CUBE_C, -U_CUBE_C, -U_CUBE_C, 1.0 ); i++;
    vertices[i] = point4( -U_CUBE_C,  U_CUBE_C, -U_CUBE_C, 1.0 ); i++;
    vertices[i] = point4(  U_CUBE_C,  U_CUBE_C, -U_CUBE_C, 1.0 ); i++;
    vertices[i] = point4(  U_CUBE_C, -U_CUBE_C, -U_CUBE_C, 1.0 ); //end
    return vertices;
}
//Begin FanGen
void FanGen::generate(const color4& insideColor, const color4& outsideColor) {
	const float init = M_PI / 4.0;
	const float theta = M_PI / 9.0;
	//set vertices
	elements[0] = MatMath::ORIGIN;
	for (int i = 1; i < 5; ++i)
		elements[i] = point4(cos(init + (i - 1) * theta), sin(init + (i - 1) * theta), 0.0, 1.0);
	//set colors
	elements[5] = insideColor; elements[6] = outsideColor;
	//set normals
	elements[7] = MatMath::zNORM; elements[8] = -MatMath::zNORM;


	//front points
	data[0] = elements[0];
	for (int i = 1; i < 5; ++i)
		data[i] = elements[i];
	//back points
	data[5] = elements[0];
	for (int i = 1; i < 5; ++i)
		data[i + 5] = elements[5 - i];
	//colors
	data[10] = data[15] = insideColor;
	for (int i = 1; i < 5; ++i) {
		//front
		data[i + 10] = outsideColor;
		//back
		data[i + 15] = outsideColor;
	}
	//normals
	for (int i = 0; i < 5; ++i) {
		//front
		data[20 + i] = MatMath::zNORM;
		//bacl
		data[25 + i] = -MatMath::zNORM;
	}

	//front fan
	for (int i = 0; i < 3; ++i) {
		indices[3 * i] = 0;
		indices[3 * i + 1] = i + 1;
		indices[3 * i + 2] = i + 2;
	}
	//back fan
	for (int i = 0; i < 3; ++i) {
		indices[3 * (i + 3)] = 5;
		indices[3 * (i + 3) + 1] = i + 6;
		indices[3 * (i + 3) + 2] = i + 7;
	}
}
Beispiel #20
0
void WCX_floor::generateAxis(){
	// axis x
	axis_points[0] = point4(0.0,0.0,0.0,1.0);	axis_colors[0] = color4(1.0,0.0,0.0,1.0);
	axis_points[1] = point4(10.0,0.0,0.0,1.0);	axis_colors[1] = color4(1.0,0.0,0.0,1.0);
	axis_points[2] = point4(0.0,0.0,0.0,1.0);	axis_colors[2] = color4(1.0,0.0,1.0,1.0);
	axis_points[3] = point4(0.0,10.0,0.0,1.0);	axis_colors[3] = color4(1.0,0.0,1.0,1.0);
	axis_points[4] = point4(0.0,0.0,0.0,1.0);	axis_colors[4] = color4(0.0,0.0,1.0,1.0);
	axis_points[5] = point4(0.0,0.0,10.0,1.0);	axis_colors[5] = color4(0.0,0.0,1.0,1.0);
}
void EyeCalibration::createTestData() {

	CalibrationPoint point1(20, 5, osg::Vec3(-1.2f, -1.f, 2.f));
	calibrationPoints.push_back(point1);

	CalibrationPoint point2(700, 25, osg::Vec3(1.4f, -1.f, 1.6f));
	calibrationPoints.push_back(point2);

	CalibrationPoint point3(-10, 520, osg::Vec3(-0.8f, -1.f, -1.4f));
	calibrationPoints.push_back(point3);

	CalibrationPoint point4(730, 542, osg::Vec3(1.f, -1.f, -1.3f));
	calibrationPoints.push_back(point4);

}
Beispiel #22
0
bool pocketCollision(sphere* sphere1)
{
	float disty =distance(sphere1->currpos, point4(sphere1->currpos.x,2,0,1)); //collision with top wall
	float distny = distance(sphere1->currpos, point4(sphere1->currpos.x,-2,0,1)); //collision with bottom wall
	float distx = distance(sphere1->currpos, point4(1,sphere1->currpos.y,0,1)); //collision with right wall
	float distnx = distance(sphere1->currpos, point4(-1,sphere1->currpos.y,0,1)); //collision with left wall
	//collision with top wall
	//top left
	if((sphere1->currpos.y>1.86) && (sphere1->currpos.x<=-.9))
	{ 
		return false;
	}
	//top right
	if((sphere1->currpos.y>1.86) && (sphere1->currpos.x>=.9))
	{ 
		return false;
	}
	//left
	if((sphere1->currpos.x<=-.9) && (sphere1->currpos.y<.1 && sphere1->currpos.y>-.1)) { 
		return false;
	}
	//right
	if((sphere1->currpos.x>=.9) && (sphere1->currpos.y<.1 && sphere1->currpos.y>-.1)) {
		return false;
	}
	//bottom left
	if((sphere1->currpos.y<-1.86) && (sphere1->currpos.x<=-.88)) { 
		return false;
	}
	//bottom right
	if((sphere1->currpos.y<-1.86) && (sphere1->currpos.x>=.88)) { 
		return false;
	}

	return true;
}
Beispiel #23
0
void poly4::calcCenter4() {
	int mSize = points4.size();
	
	if (mSize == 0){
		std::cout << "Error : poly::calcCenter4() called with empty points4 " << std::endl;
		exit(1);
	}
	
	center4 = point4(0.,0.,0.,0.);
	for (int i=0;i<mSize;i++){
		center4 += points4[i];
	}
	center4 /= double(mSize);
		//	std::cout << "center = " << center4 << std::endl;
}
void MyPrimitive::GenerateCube(float a_mSize, vector3 a_vColor)
{
	//If the size is less than this make it this large
	if (a_mSize < 0.01f)
		a_mSize = 0.01f;

	//Clean up Memory
	Release();
	Init();

	float fValue = 0.5f * a_mSize;
	//3--2
	//|  |
	//0--1
	vector3 point0(-fValue, -fValue, fValue); //0
	vector3 point1(fValue, -fValue, fValue); //1
	vector3 point2(fValue, fValue, fValue); //2
	vector3 point3(-fValue, fValue, fValue); //3

	//7--6
	//|  |
	//4--5
	vector3 point4(-fValue, -fValue, -fValue); //4
	vector3 point5(fValue, -fValue, -fValue); //5
	vector3 point6(fValue, fValue, -fValue); //6
	vector3 point7(-fValue, fValue, -fValue); //7

	//F
	AddQuad(point0, point1, point3, point2);

	//B
	AddQuad(point5, point4, point6, point7);

	//L
	AddQuad(point4, point0, point7, point3);

	//R
	AddQuad(point1, point5, point2, point6);

	//U
	AddQuad(point3, point2, point7, point6);

	//D
	AddQuad(point4, point5, point0, point1);

	//Compile the object in this color and assign it this name
	CompileObject(a_vColor);
}
Beispiel #25
0
	CubeCreator::CubeCreator(float width, float height, float depth) : index(0) {
		float hW = width / 2;
		float hH = height / 2;
		float hD = depth / 2;

		vertices[0] = point4(-hW, -hH, hD, 1.0);
		vertices[1] = point4(-hW, hH, hD, 1.0);
		vertices[2] = point4(hW, hH, hD, 1.0);
		vertices[3] = point4(hW, -hH, hD, 1.0);
		vertices[4] = point4(-hW, -hH, -hD, 1.0);
		vertices[5] = point4(-hW, hH, -hD, 1.0);
		vertices[6] = point4(hW, hH, -hD, 1.0);
		vertices[7] = point4(hW, -hH, -hD, 1.0);

		colors_[0] = { 0.0f, 0.0f, 0.0f };
		colors_[1] = { 0.0f, 0.0f, 1.0f };
		colors_[2] = { 0.0f, 1.0f, 0.0f };
		colors_[3] = { 0.0f, 1.0f, 1.0f };
		colors_[4] = { 1.0f, 0.0f, 0.0f };
		colors_[5] = { 1.0f, 0.0f, 1.0f };
		colors_[6] = { 1.0f, 1.0f, 0.0f };
		colors_[7] = { 1.0f, 1.0f, 1.0f };

		//fe::fill(colors_, glm::vec3(1.f));

		face_colors_ = {
			glm::vec3(1.f, 0.f, 0.f),
			glm::vec3(0.f, 0.f, 1.f),
			glm::vec3(1.f, 1.f, 0.f),
			glm::vec3(1.f, 0.f, 0.f),
			glm::vec3(1.f, 0.f, 1.f),
			glm::vec3(1.f, 0.f, 0.f),
		};

		fe::fill(face_colors_, glm::vec3(1.f));

		quad(1, 0, 3, 2);
		quad(2, 3, 7, 6);
		quad(3, 0, 4, 7);
		quad(6, 5, 1, 2);
		quad(4, 5, 6, 7);
		quad(5, 4, 0, 1);
	}
void MyPrimitive::GenerateCube(float a_fSize, vector3 a_v3Color)
{
	if (a_fSize < 0.01f)
		a_fSize = 0.01f;

	Release();
	Init();

	float fValue = 0.5f * a_fSize;
	//3--2
	//|  |
	//0--1
	vector3 point0(-fValue, -fValue, fValue); //0
	vector3 point1(fValue, -fValue, fValue); //1
	vector3 point2(fValue, fValue, fValue); //2
	vector3 point3(-fValue, fValue, fValue); //3

	vector3 point4(-fValue, -fValue, -fValue); //4
	vector3 point5(fValue, -fValue, -fValue); //5
	vector3 point6(fValue, fValue, -fValue); //6
	vector3 point7(-fValue, fValue, -fValue); //7

											  //F
	AddQuad(point0, point1, point3, point2);

	//B
	AddQuad(point5, point4, point6, point7);

	//L
	AddQuad(point4, point0, point7, point3);

	//R
	AddQuad(point1, point5, point2, point6);

	//U
	AddQuad(point3, point2, point7, point6);

	//D
	AddQuad(point4, point5, point0, point1);

	CompileObject(a_v3Color);
}
void MyPrimitive::GenerateCylinder(float a_fRadius, float a_fHeight, int a_nSubdivisions, vector3 a_v3Color)
{
	if (a_nSubdivisions < 3)
		a_nSubdivisions = 3;
	if (a_nSubdivisions > 360)
		a_nSubdivisions = 360;

	Release();
	Init();

	//Your code starts here
	float fValue = 0.5f;
	//3--2
	//|  |
	//0--1
	//vector3 point0(-fValue, -fValue, fValue); //0
	//vector3 point1(fValue, -fValue, fValue); //1
	//vector3 point2(fValue, fValue, fValue); //2
	//vector3 point3(-fValue, fValue, fValue); //3
	//
	//AddQuad(point0, point1, point3, point2);
		vector3 point0(0, 0, 0); 
		vector3 point1(0, a_fHeight, 0); 
	for (int i = 0; i < a_nSubdivisions; i++)
	{
		float ang = (2 * PI) / a_nSubdivisions;

		
		vector3 point2(a_fRadius*cos(i*ang), 0, a_fRadius*sin(i*ang)); //0
		vector3 point3(a_fRadius*cos((i + 1)*ang), 0, a_fRadius*sin((i + 1)*ang)); //3


		vector3 point4(a_fRadius*cos(i*ang), a_fHeight, a_fRadius*sin(i*ang)); //0
		vector3 point5(a_fRadius*cos((i + 1)*ang), a_fHeight, a_fRadius*sin((i + 1)*ang)); //3

		AddQuad(point1, point3, point2, point4);
		AddQuad(point1, point4, point5, point3);
	}
	//Your code ends here
	CompileObject(a_v3Color);
}
/**
 * @brief Determines if any edge of the polygon intersects with any edge of a branch
 * @param currLeaf
 * @return
 */
bool PolygonSearch::PolygonHasEdgeIntersection(leaf *currLeaf)
{
	Point point1(currLeaf->bounds[0], currLeaf->bounds[2]);	/* Bottom Left */
	Point point2(currLeaf->bounds[1], currLeaf->bounds[2]);	/* Bottom Right */
	Point point3(currLeaf->bounds[0], currLeaf->bounds[3]);	/* Top Left */
	Point point4(currLeaf->bounds[1], currLeaf->bounds[3]);	/* Top Right */
	unsigned int pointCount = polygonPoints.size();

	for (unsigned int i=0; i<pointCount-1; ++i)
		if (EdgesIntersect(point1, point2, polygonPoints[i], polygonPoints[i+1]) ||
		    EdgesIntersect(point1, point3, polygonPoints[i], polygonPoints[i+1]) ||
		    EdgesIntersect(point3, point4, polygonPoints[i], polygonPoints[i+1]) ||
		    EdgesIntersect(point2, point4, polygonPoints[i], polygonPoints[i+1]))
			return true;
	if (EdgesIntersect(point1, point2, polygonPoints[0], polygonPoints[pointCount-1]) ||
	    EdgesIntersect(point1, point3, polygonPoints[0], polygonPoints[pointCount-1]) ||
	    EdgesIntersect(point3, point4, polygonPoints[0], polygonPoints[pointCount-1]) ||
	    EdgesIntersect(point2, point4, polygonPoints[0], polygonPoints[pointCount-1]))
		return true;
	return false;
}
Beispiel #29
0
void Terra::make(){
    static vec3  base_colors[] = {
        vec3( 1.0, 0.0, 0.0 ),
        vec3( 0.0, 1.0, 0.0 ),
        vec3( 0.0, 0.0, 1.0 ),
        vec3( 1.0, 1.0, 0.0 )
    };

    Index=6;
    this->points[0] = point4(-x, y,-z, 1.0);
    this->points[1] = point4( x, y,-z, 1.0);
    this->points[2] = point4(-x, y, z, 1.0);
    this->points[3] = point4(-x, y, z, 1.0);
    this->points[4] = point4( x, y,-z, 1.0);
    this->points[5] = point4( x, y, z, 1.0);
}
Beispiel #30
0
Cube::Cube(vec3 pos, vec3 s)
{
    numVertices = 36;
    quadIndex = 0;
    position = pos;
    scale = s;
    points = new point4[numVertices];
    normals = new vec3[numVertices];

    diffuse = color4(0.2, 0.2, 0.6, 1.0);
    ambient = color4(1.0, 1.0, 1.0, 1.0);
    specular = color4(1.0, 1.0, 1.0, 1.0);
    shininess = 100.0;

    vertices = new point4[8];
    vertices[0] = point4( -0.5, -0.5,  0.5, 1.0 );
    vertices[1] = point4( -0.5,  0.5,  0.5, 1.0 );
    vertices[2] = point4(  0.5,  0.5,  0.5, 1.0 );
    vertices[3] = point4(  0.5, -0.5,  0.5, 1.0 );
    vertices[4] = point4( -0.5, -0.5, -0.5, 1.0 );
    vertices[5] = point4( -0.5,  0.5, -0.5, 1.0 );
    vertices[6] = point4(  0.5,  0.5, -0.5, 1.0 );
    vertices[7] = point4(  0.5, -0.5, -0.5, 1.0 );

    vertex_colors = new point4[8];
    vertex_colors[0] = color4( 0.0, 0.0, 0.0, 1.0 );
    vertex_colors[1] = color4( 1.0, 0.0, 0.0, 1.0 );
    vertex_colors[2] = color4( 1.0, 1.0, 0.0, 1.0 );
    vertex_colors[3] = color4( 0.0, 1.0, 0.0 , 1.0 );
    vertex_colors[4] = color4( 0.0, 0.0, 1.0, 1.0 );
    vertex_colors[5] = color4( 1.0, 0.0, 1.0, 1.0 );
    vertex_colors[6] = color4( 1.0, 1.0, 1.0, 1.0 );
    vertex_colors[7] = color4( 0.0, 1.0, 1.0, 1.0 );

    colorcube();
    setUpShader();
}