bool AABBox<Point3f>::intersection<Point3f>(Point3f const & point, float tolerance)
{
	if (point.x() + tolerance < m_minCor.x() || point.x() - tolerance > m_maxCor.x())
		return false;
	if (point.y() + tolerance < m_minCor.y() || point.y() - tolerance > m_maxCor.y())
		return false;
	if (point.z() + tolerance < m_minCor.z() || point.z() - tolerance > m_maxCor.z())
		return false;
	return true;
}
float AABBox<Point3f>::squared_distance<Point3f>(Point3f const & point)
{
	if (this->intersection<Point3f>(point, 0.0f))
		return 0.0f;

	float delta_x = (std::max)((std::max)(this->m_minCor.x() - point.x(), point.x() - this->m_maxCor.x()), 0.0f);
	float delta_y = (std::max)((std::max)(this->m_minCor.y() - point.y(), point.y() - this->m_maxCor.y()), 0.0f);
	float delta_z = (std::max)((std::max)(this->m_minCor.z() - point.z(), point.z() - this->m_maxCor.z()), 0.0f);

	//std::cout << "delta x " << delta_x << " delta y " << delta_y << " delta z " << delta_z << std::endl;

	return delta_x * delta_x + delta_y * delta_y + delta_z * delta_z;
}
Beispiel #3
0
	WavefrontOBJ(const PropertyList &propList) {
		typedef boost::unordered_map<OBJVertex, uint32_t, OBJVertexHash> VertexMap;

		/* Process the OBJ-file line by line */	
		QString filename = propList.getString("filename");
		QFile input(filename);
		if (!input.open(QIODevice::ReadOnly | QIODevice::Text))
			throw NoriException(QString("Cannot open \"%1\"").arg(filename));

		Transform trafo = propList.getTransform("toWorld", Transform());

		cout << "Loading \"" << qPrintable(filename) << "\" .." << endl;
		m_name = filename;

		QTextStream stream(&input);
		QTextStream line;
		QString temp, prefix;

		std::vector<Point3f>   positions;
		std::vector<Point2f>   texcoords;
		std::vector<Normal3f>  normals;
		std::vector<uint32_t>  indices;
		std::vector<OBJVertex> vertices;
		VertexMap vertexMap;

		while (!(temp = stream.readLine()).isNull()) {
			line.setString(&temp);

			line >> prefix;
			if (prefix == "v") {
				Point3f p;
				line >> p.x() >> p.y() >> p.z();
				p = trafo * p;
				positions.push_back(p);
			} else if (prefix == "vt") {
Beispiel #4
0
  /// Return false if the particle is dead
  bool advance(float dt)
  {
    if (curtime >= t0 + maxlife)
			return false;

    // gravity
	vit.z() -= gravity * dt;

	// update
	pos += vit * dt;

	// collision
	if (pos.z() < 0)
	{
		float dv = vit.z();

		pos.z() = 0;
		if (dv < 0)
		{
			vit.z() = -0.8f * vit.z();
			last_col = curtime; //-d;
		}
	}

	// color
	float c = curtime - last_col;

	if (c > 1)
		c = 1;

	color.x() = 1 - c;
	return true;
  }
Beispiel #5
0
	/**
	 * \brief Evaluate sigma_t(p), where 'p' is given in local coordinates
	 *
	 * You may assume that the maximum value returned by this function is
	 * equal to 'm_densityMultiplier'
	 */
	float lookupSigmaT(const Point3f &_p) const {
		Point3f p  = _p.cwiseProduct(m_resolution.cast<float>()),
				pf = Point3f(std::floor(p.x()), std::floor(p.y()), std::floor(p.z()));
		Point3i p0 = pf.cast<int>();

		if ((p0.array() < 0).any() || (p0.array() >= m_resolution.array() - 1).any())
			return 0.0f;

		size_t row    = m_resolution.x(),
		       slab   = row * m_resolution.y(),
		       offset = p0.z()*slab + p0.y()*row + p0.x();

		const float
			d000 = m_data[offset],
			d001 = m_data[offset + 1],
			d010 = m_data[offset + row],
			d011 = m_data[offset + row + 1],
			d100 = m_data[offset + slab],
			d101 = m_data[offset + slab + 1],
			d110 = m_data[offset + slab + row],
			d111 = m_data[offset + slab + row + 1];

		Vector3f w1 = p-pf, w0 = (1 - w1.array()).matrix();

		/* Trilinearly interpolate */
		return (((d000 * w0.x() + d001 * w1.x()) * w0.y() +
		         (d010 * w0.x() + d011 * w1.x()) * w1.y()) * w0.z() +
		        ((d100 * w0.x() + d101 * w1.x()) * w0.y() +
		         (d110 * w0.x() + d111 * w1.x()) * w1.y()) * w1.z()) * m_densityMultiplier;
	}
void GraphicsPainter::drawCircle(const Point3f &center, float radius, const Vector3f &normal)
{
    Vector3f right(normal.y(), -normal.x(), 0); // vector orthogonal to normal

    glBegin(GL_TRIANGLE_FAN);

    glNormal3f(normal.x(), normal.y(), normal.z());
    glVertex3f(center.x(), center.y(), center.z());

    for(float angle = 0; angle <= 360; angle += 10){
        Point3f point = center + (chemkit::geometry::rotate(right, normal, angle).normalized() * radius);

        glNormal3f(normal.x(), normal.y(), normal.z());
        glVertex3f(point.x(), point.y(), point.z());
    }

    glEnd();
}
void GraphicsPainter::drawSphere(const Point3f &center, float radius)
{
    glPushMatrix();
    glTranslated(center.x(), center.y(), center.z());

    drawSphere(radius);

    glPopMatrix();
}
Beispiel #8
0
  void init(float _t0)
  {
    pos.x() = frand(0.1); pos.y() = frand(0.1); pos.z() = 0.00;

    int angle = nrand(minangle, maxangle);
    float angle_rad = (float(angle)/180.0f)*3.14159265f;
    vit.x() = ::cos(angle_rad);
    vit.y() = ::sin(angle_rad);
    vit.z() = 0;

    //    vit.x() = frand(2)-1; vit.y() = frand(2)-1; vit.z() = 0;

    vit.normalize();
    vit.z() = 2+frand(2);
    color.x() = 0;
    color.y() = 0.5f+frand(0.5f);
    color.z() = 0.9f+frand(0.1f);
    t0 = _t0;
    last_col = t0;
  }
/// Multiplies \p point by the inverse of the transform.
Point3f GraphicsTransform::inverseMultiplyPoint(const Point3f &point) const
{
    Eigen::Matrix<float, 4, 1> vector4;
    vector4[0] = point.x();
    vector4[1] = point.y();
    vector4[2] = point.z();
    vector4[3] = 1;

    vector4 = m_matrix->inverse() * vector4;

    return Point3f(vector4[0], vector4[1], vector4[2]);
}
Beispiel #10
0
/// Returns the depth of point in the scene.
float GraphicsView::depth(const Point3f &point) const
{
    Eigen::Matrix<float, 4, 1> viewPoint;
    viewPoint[0] = point.x();
    viewPoint[1] = point.y();
    viewPoint[2] = point.z();
    viewPoint[3] = 1;

    GraphicsTransform transform = projectionTransform() * modelViewTransform();
    viewPoint = transform.multiply(viewPoint);
    viewPoint *= 1.0 / viewPoint[3];

    float winZ = (viewPoint[2] + 1) / 2;

    return winZ;
}
void GraphicsPainter::drawCylinder(const Point3f &a, const Point3f &b, float radius)
{
    glPushMatrix();

    glTranslatef(a.x(), a.y(), a.z());

    Vector3f vector = (a - b).normalized();
    Vector3f axis = vector.cross(-Vector3f::UnitZ()).normalized();
    float angle = chemkit::geometry::angle(vector.cast<Real>(), -Vector3f::UnitZ().cast<Real>());
    glRotatef(-angle, axis.x(), axis.y(), axis.z());

    float length = chemkit::geometry::distance(a.cast<Real>(), b.cast<Real>());

    drawCylinder(radius, length);

    glPopMatrix();
}
Beispiel #12
0
void Cube::update(const Vector3f &min, const Vector3f &max) {
	std::string v =
	std::to_string(max.x()) + " " + std::to_string(min.y()) + " " + std::to_string(min.z()) + "\n" +
	std::to_string(max.x()) + " " + std::to_string(min.y()) + " " + std::to_string(max.z()) + "\n" +
	std::to_string(min.x()) + " " + std::to_string(min.y()) + " " + std::to_string(max.z()) + "\n" +
	std::to_string(min.x()) + " " + std::to_string(min.y()) + " " + std::to_string(min.z()) + "\n" +
	std::to_string(max.x()) + " " + std::to_string(max.y()) + " " + std::to_string(min.z()) + "\n" +
	std::to_string(max.x()) + " " + std::to_string(max.y()) + " " + std::to_string(max.z()) + "\n" +
	std::to_string(min.x()) + " " + std::to_string(max.y()) + " " + std::to_string(max.z()) + "\n" +
	std::to_string(min.x()) + " " + std::to_string(max.y()) + " " + std::to_string(min.z()) + "\n";

	std::istringstream is(v);
	std::string line_str;
	std::vector<Vector3f> newPos;
	m_bbox.reset();
	while (std::getline(is, line_str)) {
		std::istringstream line(line_str);
		
		Point3f p;
		line >> p.x() >> p.y() >> p.z();
		newPos.push_back(p);
		m_bbox.expandBy(p);
	}

	for (uint32_t i = 0; i < m_V.cols(); ++i)
		m_V.col(i) = newPos.at(vertices[i].p - 1);

	// Update data on GPU
	glBindVertexArray(vao);
	glBindBuffer(GL_ARRAY_BUFFER, vbo[VERTEX_BUFFER]);
	// Update data only
	void* ptr = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
	if (ptr) {
		memcpy(ptr, (const uint8_t *)m_V.data(), 3 * m_V.cols() * sizeof(GLfloat));
		glUnmapBuffer(GL_ARRAY_BUFFER);
	}
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);
}
Beispiel #13
0
/// Projects a point from the scene to the window.
QPointF GraphicsView::project(const Point3f &point) const
{
    Eigen::Matrix<float, 4, 1> vector;
    vector[0] = point.x();
    vector[1] = point.y();
    vector[2] = point.z();
    vector[3] = 0;

    GraphicsTransform transform = projectionTransform() * modelViewTransform();
    vector = transform.multiply(vector);
    vector *= 1.0 / vector[3];

    float winX = width() * (vector[0] + 1) / 2;
    float winY = height() * (vector[1] + 1) / 2;
    float winZ = (vector[2] + 1) / 2;

    // if winZ is greater than 1.0 the point is not
    // visible (it is either in front of the near clip
    // plane or behind the far clip plane).
    if(winZ > 1.0)
        return QPointF();
    else
        return QPointF(winX, height() - winY);
}
Beispiel #14
0
Point3f::Point3f(const Point3f &_p) 
    : x_(_p.x()), y_(_p.y()), z_(_p.z()) {}
Beispiel #15
0
Point3f operator-(const Point3f &_p, const Vector3f &_v) {
    return Point3f(_p.x()-_v.x(), _p.y()-_v.y(), _p.z()-_v.z());
}
Beispiel #16
0
Vector3f operator-(const Point3f &_p1, const Point3f &_p2) {
    return Vector3f(_p1.x()-_p2.x(), _p1.y()-_p2.y(), _p1.z()-_p2.z());
}