void VPLShaderManager::drawBackground(const Sensor *sensor,
const Transform &projectionTransform, Float scaleFactor) {
if (m_backgroundProgram == NULL)
return;
const Transform &trafo = sensor->getWorldTransform()->eval(0);
Transform clipToWorld = trafo
* Transform::scale(Vector(-1, 1, -1)) * projectionTransform.inverse();
GPUProgram *prog = m_backgroundProgram;
int tuOffset = 0;
prog->bind();
m_backgroundDependencies.bind(prog, m_backgroundDependencies, tuOffset);
if (sensor->getType() & Sensor::EOrthographicCamera) {
Vector d = trafo(Vector(0.0f, 0.0f, 1.0f));
prog->setParameter(m_backgroundParam_camDirection, d);
} else {
Point p = trafo(Point(0.0f));
prog->setParameter(m_backgroundParam_camPosition, p);
}
prog->setParameter(m_backgroundParam_emitterScale, scaleFactor);
prog->setParameter(m_backgroundParam_clipToWorld, clipToWorld);
m_renderer->blitQuad(false);
prog->unbind();
m_backgroundDependencies.unbind();
}
void fillIntersectionRecord(const Ray &ray,
const void *temp, Intersection &its) const {
const Float *data = static_cast<const Float *>(temp);
Float r = std::sqrt(data[0] * data[0] + data[1] * data[1]),
invR = (r == 0) ? 0.0f : (1.0f / r);
Float phi = std::atan2(data[1], data[0]);
if (phi < 0)
phi += 2*M_PI;
Float cosPhi = data[0] * invR, sinPhi = data[1] * invR;
const Transform &trafo = m_objectToWorld->eval(ray.time);
its.shape = this;
if (r != 0) {
its.dpdu = trafo(Vector(cosPhi, sinPhi, 0));
its.dpdv = trafo(Vector(-sinPhi, cosPhi, 0));
} else {
its.dpdu = trafo(Vector(1, 0, 0));
its.dpdv = trafo(Vector(0, 1, 0));
}
its.shFrame.n = normalize(trafo(Normal(0, 0, 1)));
its.uv = Point2(r, phi * INV_TWOPI);
its.p = ray(its.t);
its.hasUVPartials = false;
its.instance = NULL;
its.time = ray.time;
}
Spectrum samplePosition(PositionSamplingRecord &pRec, const Point2 &sample, const Point2 *extra) const {
const Transform &trafo = m_worldTransform->eval(pRec.time);
pRec.p = trafo(Point(0.0f));
pRec.n = trafo(Vector(0.0f, 0.0f, 1.0f));
pRec.pdf = 1.0f;
pRec.measure = EDiscrete;
return m_power;
}
void samplePosition(PositionSamplingRecord &pRec, const Point2 &sample) const {
const Transform &trafo = m_objectToWorld->eval(pRec.time);
Point2 p = warp::squareToUniformDiskConcentric(sample);
pRec.p = trafo(Point3(p.x, p.y, 0));
pRec.n = normalize(trafo(Normal(0, 0, 1)));
pRec.pdf = m_invSurfaceArea;
pRec.measure = EArea;
}
void configure() {
ProjectiveCamera::configure();
const Vector2i &filmSize = m_film->getSize();
const Vector2i &cropSize = m_film->getCropSize();
const Point2i &cropOffset = m_film->getCropOffset();
Vector2 relSize((Float) cropSize.x / (Float) filmSize.x,
(Float) cropSize.y / (Float) filmSize.y);
Point2 relOffset((Float) cropOffset.x / (Float) filmSize.x,
(Float) cropOffset.y / (Float) filmSize.y);
/**
* These do the following (in reverse order):
*
* 1. Create transform from camera space to [-1,1]x[-1,1]x[0,1] clip
* coordinates (not taking account of the aspect ratio yet)
*
* 2+3. Translate and scale to shift the clip coordinates into the
* range from zero to one, and take the aspect ratio into account.
*
* 4+5. Translate and scale the coordinates once more to account
* for a cropping window (if there is any)
*/
m_cameraToSample =
Transform::scale(Vector(1.0f / relSize.x, 1.0f / relSize.y, 1.0f))
* Transform::translate(Vector(-relOffset.x, -relOffset.y, 0.0f))
* Transform::scale(Vector(-0.5f, -0.5f*m_aspect, 1.0f))
* Transform::translate(Vector(-1.0f, -1.0f/m_aspect, 0.0f))
* Transform::orthographic(m_nearClip, m_farClip);
m_sampleToCamera = m_cameraToSample.inverse();
/* Position differentials on the near plane */
m_dx = m_sampleToCamera(Point(m_invResolution.x, 0.0f, 0.0f))
- m_sampleToCamera(Point(0.0f));
m_dy = m_sampleToCamera(Point(0.0f, m_invResolution.y, 0.0f))
- m_sampleToCamera(Point(0.0f));
/* Clip-space transformation for OpenGL */
m_clipTransform = Transform::translate(
Vector((1-2*relOffset.x)/relSize.x - 1,
-(1-2*relOffset.y)/relSize.y + 1, 0.0f)) *
Transform::scale(Vector(1.0f / relSize.x, 1.0f / relSize.y, 1.0f));
const Transform &trafo = m_worldTransform->eval(0.0f);
m_invSurfaceArea = 1.0f / (
trafo(m_sampleToCamera(Vector(1, 0, 0))).length() *
trafo(m_sampleToCamera(Vector(0, 1, 0))).length());
m_scale = trafo(Vector(0, 0, 1)).length();
}
Spectrum sampleRay(Ray &ray,
const Point2 &spatialSample,
const Point2 &directionalSample,
Float time) const {
const Transform &trafo = m_worldTransform->eval(time);
Point2 p = warp::squareToUniformDiskConcentric(spatialSample);
Vector perpOffset = trafo(Vector(p.x, p.y, 0) * m_bsphere.radius);
Vector d = trafo(Vector(0, 0, 1));
ray.setOrigin(m_bsphere.center - d*m_bsphere.radius + perpOffset);
ray.setDirection(d);
ray.setTime(time);
return m_power;
}
Spectrum samplePosition(PositionSamplingRecord &pRec, const Point2 &sample, const Point2 *extra) const {
const Transform &trafo = m_worldTransform->eval(pRec.time);
Point2 p = warp::squareToUniformDiskConcentric(sample);
Vector perpOffset = trafo(Vector(p.x, p.y, 0) * m_bsphere.radius);
Vector d = trafo(Vector(0, 0, 1));
pRec.p = m_bsphere.center - d*m_bsphere.radius + perpOffset;
pRec.n = d;
pRec.pdf = m_invSurfaceArea;
pRec.measure = EArea;
return m_power;
}
AABB getAABB() const {
std::set<Float> times;
m_objectToWorld->collectKeyframes(times);
AABB aabb;
for (std::set<Float>::iterator it = times.begin(); it != times.end(); ++it) {
const Transform &trafo = m_objectToWorld->eval(*it);
aabb.expandBy(trafo(Point( 1, 0, 0)));
aabb.expandBy(trafo(Point(-1, 0, 0)));
aabb.expandBy(trafo(Point( 0, 1, 0)));
aabb.expandBy(trafo(Point( 0, -1, 0)));
}
return aabb;
}
void configure() {
Shape::configure();
const Transform &trafo = m_objectToWorld->eval(0);
Vector dpdu = trafo(Vector(1, 0, 0));
Vector dpdv = trafo(Vector(0, 1, 0));
if (std::abs(dot(normalize(dpdu), normalize(dpdv))) > 1e-3f)
Log(EError, "Error: 'toWorld' transformation contains shear!");
if (std::abs(dpdu.length() / dpdv.length() - 1) > 1e-3f)
Log(EError, "Error: 'toWorld' transformation contains a non-uniform scale!");
m_invSurfaceArea = 1.0f / (M_PI * dpdu.length() * dpdu.length());
}
ComputeIconMasks(IconTaskCtx& ctx)
: ctx(ctx)
{
// clamp the icon size
iconSizecv = cv::Size(
clamp(ctx.iconSize.width(),
IconTask::IconSizeMin, IconTask::IconSizeMax),
clamp(ctx.iconSize.height(),
IconTask::IconSizeMin, IconTask::IconSizeMax));
// inner size = icon size without border (fixed to 1px)
innerSize = QSize(iconSizecv.width - 2,
iconSizecv.height - 2);
innerSizecv = cv::Size(innerSize.width(), innerSize.height());
if (ctx.applyROI) {
labels = ctx.roi_labels;
} else {
labels = ctx.full_labels;
}
scale = scaleToFit(labels.size(), innerSizecv);
// offset into icon rect
dx = 0.5 * (float(iconSizecv.width) - labels.cols*scale);
dy = 0.5 * (float(iconSizecv.height) - labels.rows*scale);
// affine trafo matrix
trafo = cv::Mat1f::zeros(2,3);
trafo(0,0) = scale;
trafo(1,1) = scale;
trafo(0,2) = dx;
trafo(1,2) = dy;
// rect of the transformed mask in the icon
drect = QRectF(dx, dy,
labels.cols*scale, labels.rows*scale);
// rect of the border around the transformed mask
brect = QRectF(drect.left(), drect.top(),
drect.width()-1, drect.height()-1);
// GGDBGM("desired icon size " << iconSizecv << endl);
// GGDBGM("scale " << scale << endl);
// GGDBGM("dx " << dx << endl);
// GGDBGM("dy " << dy << endl);
// GGDBGM("scaled mask size " << innerSizecv << endl);
}
Spectrum sampleDirect(DirectSamplingRecord &dRec, const Point2 &) const {
const Transform &trafo = m_worldTransform->eval(dRec.time);
dRec.n = trafo(Vector(0, 0, 1));
Float scale = dRec.n.length();
Point localP = trafo.inverse().transformAffine(dRec.ref);
localP.z *= scale;
Point sample = m_cameraToSample.transformAffine(localP);
if (sample.x < 0 || sample.x > 1 || sample.y < 0 ||
sample.y > 1 || sample.z < 0 || sample.z > 1) {
dRec.pdf = 0.0f;
return Spectrum(0.0f);
}
dRec.p = trafo.transformAffine(Point(localP.x, localP.y, 0.0f));
dRec.n /= scale;
dRec.d = -dRec.n;
dRec.dist = localP.z;
dRec.uv = Point2(sample.x * m_resolution.x,
sample.y * m_resolution.y);
dRec.pdf = 1.0f;
dRec.measure = EDiscrete;
return Spectrum(m_invSurfaceArea);
}
int main (int argc, char** argv)
{
if (argc != 3)
{
ROS_INFO_STREAM("please provide a pointcloud file followed by a text file containing a transformation matrix as arguments");
exit(0);
}
pcl::PCDReader reader;
pcl::PointCloud<PointType>::Ptr cloudIn (new pcl::PointCloud<PointType>);
pcl::PointCloud<PointType>::Ptr cloudOut (new pcl::PointCloud<PointType>);
pcl::PointCloud<PointType>::Ptr cloudOut_inv (new pcl::PointCloud<PointType>);
Eigen::Matrix4f trafo, trafo_inv;
reader.read (argv[1], *cloudIn);
std::ifstream myfile;
myfile.open (argv[2]);
for (int row = 0; row < 4; row++)
for (int col = 0; col < 4; col++)
{
myfile >> trafo (row, col);
}
trafo_inv = trafo.inverse();
ROS_INFO_STREAM("transform to be used: \n" << trafo);
transformPointCloud (*cloudIn, *cloudOut, trafo);
transformPointCloud (*cloudIn, *cloudOut_inv, trafo_inv);
pcl::PCDWriter writer;
writer.write ("output.pcd", *cloudOut, false);
writer.write ("output_inverse.pcd", *cloudOut_inv, false);
return (0);
}
Transform Transform::perspective(Float fov, Float clipNear, Float clipFar) {
/* Project vectors in camera space onto a plane at z=1:
*
* xProj = x / z
* yProj = y / z
* zProj = (far * (z - near)) / (z * (far-near))
*
* Camera-space depths are not mapped linearly!
*/
Float recip = 1.0f / (clipFar - clipNear);
/* Perform a scale so that the field of view is mapped
* to the interval [-1, 1] */
Float cot = 1.0f / std::tan(degToRad(fov / 2.0f));
Matrix4x4 trafo(
cot, 0, 0, 0,
0, cot, 0, 0,
0, 0, clipFar * recip, -clipNear * clipFar * recip,
0, 0, 1, 0
);
return Transform(trafo);
}
Spectrum sampleDirection(DirectionSamplingRecord &dRec,
PositionSamplingRecord &pRec,
const Point2 &sample, const Point2 *extra) const {
const Transform &trafo = m_worldTransform->eval(pRec.time);
Point samplePos(sample.x, sample.y, 0.0f);
if (extra) {
/* The caller wants to condition on a specific pixel position */
samplePos.x = (extra->x + sample.x) * m_invResolution.x;
samplePos.y = (extra->y + sample.y) * m_invResolution.y;
}
pRec.uv = Point2(samplePos.x * m_resolution.x,
samplePos.y * m_resolution.y);
Float sinPhi, cosPhi, sinTheta, cosTheta;
math::sincos(samplePos.x * 2 * M_PI, &sinPhi, &cosPhi);
math::sincos(samplePos.y * M_PI, &sinTheta, &cosTheta);
dRec.d = trafo(Vector(sinPhi*sinTheta, cosTheta, -cosPhi*sinTheta));
dRec.measure = ESolidAngle;
dRec.pdf = 1 / (2 * M_PI * M_PI * std::max(sinTheta, Epsilon));
return Spectrum(1.0f);
}
Spectrum sampleDirection(DirectionSamplingRecord &dRec,
PositionSamplingRecord &pRec,
const Point2 &sample, const Point2 *extra) const {
const Transform &trafo = m_worldTransform->eval(pRec.time);
Point samplePos(sample.x, sample.y, 0.0f);
if (extra) {
/* The caller wants to condition on a specific pixel position */
samplePos.x = (extra->x + sample.x) * m_invResolution.x;
samplePos.y = (extra->y + sample.y) * m_invResolution.y;
}
pRec.uv = Point2(samplePos.x * m_resolution.x,
samplePos.y * m_resolution.y);
/* Compute the corresponding position on the
near plane (in local camera space) */
Point nearP = m_sampleToCamera(samplePos);
nearP.x = nearP.x * (m_focusDistance / nearP.z);
nearP.y = nearP.y * (m_focusDistance / nearP.z);
nearP.z = m_focusDistance;
Point apertureP = trafo.inverse().transformAffine(pRec.p);
/* Turn that into a normalized ray direction */
Vector d = normalize(nearP - apertureP);
dRec.d = trafo(d);
dRec.measure = ESolidAngle;
dRec.pdf = m_normalization / (d.z * d.z * d.z);
return Spectrum(1.0f);
}
Spectrum sampleRay(Ray &ray, const Point2 &pixelSample,
const Point2 &otherSample, Float timeSample) const {
Point2 tmp = warp::squareToUniformDiskConcentric(otherSample)
* m_apertureRadius;
ray.time = sampleTime(timeSample);
/* Compute the corresponding position on the
near plane (in local camera space) */
Point nearP = m_sampleToCamera(Point(
pixelSample.x * m_invResolution.x,
pixelSample.y * m_invResolution.y, 0.0f));
/* Aperture position */
Point apertureP(tmp.x, tmp.y, 0.0f);
/* Sampled position on the focal plane */
Point focusP = nearP * (m_focusDistance / nearP.z);
/* Turn these into a normalized ray direction, and
adjust the ray interval accordingly */
Vector d = normalize(focusP - apertureP);
Float invZ = 1.0f / d.z;
ray.mint = m_nearClip * invZ;
ray.maxt = m_farClip * invZ;
const Transform &trafo = m_worldTransform->eval(ray.time);
ray.setOrigin(trafo.transformAffine(apertureP));
ray.setDirection(trafo(d));
return Spectrum(1.0f);
}
void MainWindow::kiir(double pbal, double pjobb, double prev, double Sp, double Se){
double adjPrev = trafo(prev, Sp, Se);
double balvp = trafo(pbal, Sp, Se);
double jobbvp = trafo(pjobb, Sp, Se);
QString s,lb,ub,lc,uc,pr;
pr.sprintf("%.4f", prev);
lc.sprintf("%.4f", pbal);
uc.sprintf("%.4f", pjobb);
ui->plainTextEdit->appendPlainText(QString(" Observed test prevalence: %1 CI: (%2 , %3)").arg(pr).arg(lc).arg(uc));
s.sprintf("%.4f", adjPrev);
lb.sprintf("%.4f", balvp);
ub.sprintf("%.4f", jobbvp);
ui->plainTextEdit->appendPlainText(QString(" Prevalence adjusted for Se/Sp: %1 CI: (%2 , %3)\n\n").arg(s).arg(lb).arg(ub));
}
Spectrum sampleRay(Ray &ray, const Point2 &pixelSample,
const Point2 &otherSample, Float timeSample) const {
ray.time = sampleTime(timeSample);
ray.mint = Epsilon;
ray.maxt = std::numeric_limits<Float>::infinity();
const Transform &trafo = m_worldTransform->eval(ray.time);
Float sinPhi, cosPhi, sinTheta, cosTheta;
math::sincos(pixelSample.x * m_invResolution.x * 2 * M_PI, &sinPhi, &cosPhi);
math::sincos(pixelSample.y * m_invResolution.y * M_PI, &sinTheta, &cosTheta);
Vector d(sinPhi*sinTheta, cosTheta, -cosPhi*sinTheta);
ray.setOrigin(trafo(Point(0.0f)));
ray.setDirection(trafo(d));
return Spectrum(1.0f);
}
Spectrum sampleRay(Ray &ray,
const Point2 &spatialSample,
const Point2 &directionalSample,
Float time) const {
const Transform &trafo = m_worldTransform->eval(time);
ray.setTime(time);
ray.setOrigin(trafo.transformAffine(Point(0.0f)));
ray.setDirection(trafo(Vector(0.0f, 0.0f, 1.0f)));
return m_power;
}
Spectrum sampleRayDifferential(RayDifferential &ray, const Point2 &pixelSample,
const Point2 &otherSample, Float timeSample) const {
/* Record pixel index, added by Lifan */
ray.index.x = (int)std::floor(pixelSample.x);
ray.index.y = (int)std::floor(pixelSample.y);
Point2 tmp = warp::squareToUniformDiskConcentric(otherSample)
* m_apertureRadius;
ray.time = sampleTime(timeSample);
/* Compute the corresponding position on the
near plane (in local camera space) */
Point nearP = m_sampleToCamera(Point(
pixelSample.x * m_invResolution.x,
pixelSample.y * m_invResolution.y, 0.0f));
/* Aperture position */
Point apertureP(tmp.x, tmp.y, 0.0f);
/* Sampled position on the focal plane */
Float fDist = m_focusDistance / nearP.z;
Point focusP = nearP * fDist;
Point focusPx = (nearP+m_dx) * fDist;
Point focusPy = (nearP+m_dy) * fDist;
/* Turn that into a normalized ray direction, and
adjust the ray interval accordingly */
Vector d = normalize(focusP - apertureP);
Float invZ = 1.0f / d.z;
ray.mint = m_nearClip * invZ;
ray.maxt = m_farClip * invZ;
const Transform &trafo = m_worldTransform->eval(ray.time);
ray.setOrigin(trafo.transformAffine(apertureP));
ray.setDirection(trafo(d));
ray.rxOrigin = ray.ryOrigin = ray.o;
ray.rxDirection = trafo(normalize(Vector(focusPx - apertureP)));
ray.ryDirection = trafo(normalize(Vector(focusPy - apertureP)));
ray.hasDifferentials = true;
return Spectrum(1.0f);
}
ref<TriMesh> createTriMesh() {
const uint32_t phiSteps = 40;
ref<TriMesh> mesh = new TriMesh(getName(),
phiSteps-1, 2*phiSteps, true, true, false);
Point *vertices = mesh->getVertexPositions();
Normal *normals = mesh->getVertexNormals();
Point2 *texcoords = mesh->getVertexTexcoords();
Triangle *triangles = mesh->getTriangles();
Float dphi = (2 * M_PI) / (Float) (phiSteps-1);
const Transform &trafo = m_objectToWorld->eval(0.0f);
Point center = trafo(Point(0.0f));
Normal normal = normalize(trafo(Normal(0, 0, 1)));
for (uint32_t i=0; i<phiSteps; ++i) {
Float phi = i*dphi;
vertices[i] = center;
vertices[phiSteps+i] = trafo(
Point(std::cos(phi), std::sin(phi), 0)
);
normals[i] = normal;
normals[phiSteps+i] = normal;
texcoords[i] = Point2(0.0f, phi * INV_TWOPI);
texcoords[phiSteps+i] = Point2(1.0f, phi * INV_TWOPI);
}
for (uint32_t i=0; i<phiSteps-1; ++i) {
triangles[i].idx[0] = i;
triangles[i].idx[1] = i+phiSteps;
triangles[i].idx[2] = i+phiSteps+1;
}
mesh->copyAttachments(this);
mesh->configure();
return mesh.get();
}
Transform Transform::glOrthographic(Float clipNear, Float clipFar) {
Float a = -2.0f / (clipFar - clipNear),
b = -(clipFar + clipNear) / (clipFar - clipNear);
Matrix4x4 trafo(
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, a, b,
0, 0, 0, 1
);
return Transform(trafo);
}
/*
* maximize c^T x subject to Ax = b and x >= 0
*
* inplace, b is last column of A, c first row
*/
static void simplex2(unsigned int D, unsigned int N, float A[D + 1][N + 1])
{
// 2. Loop over all columns
// print_tableaux(D, N, A);
while (true) {
unsigned int i = 0;
for (i = 0; i < N; i++)
if (A[0][i] < 0.)
break;
if (i == N)
break;
// 3. find pivot element
// Bland's rule
int pivot_index = -1;
float pivot_value = 0.;
for (unsigned int j = 1; j < D + 1; j++) {
if (0. < A[j][i]) {
float nval = A[j][N] / A[j][i];
if ((-1 == pivot_index) || (nval < pivot_value)) {
pivot_value = nval;
pivot_index = j;
}
}
}
if (-1 == pivot_index)
break;
// printf("PI %dx%d\n", pivot_index, i);
trafo(D + 1, N + 1, A, pivot_index, i);
// print_tableaux(D, N, A);
float x[N];
solution(D, N, x, A);
assert(feasible_p(D, N, x, A));
}
// print_tableaux(D, N, A);
}
Transform Transform::glPerspective(Float fov, Float clipNear, Float clipFar) {
Float recip = 1.0f / (clipNear - clipFar);
Float cot = 1.0f / std::tan(degToRad(fov / 2.0f));
Matrix4x4 trafo(
cot, 0, 0, 0,
0, cot, 0, 0,
0, 0, (clipFar + clipNear) * recip, 2 * clipFar * clipNear * recip,
0, 0, -1, 0
);
return Transform(trafo);
}
Transform Transform::glFrustum(Float left, Float right, Float bottom, Float top, Float nearVal, Float farVal) {
Float invFMN = 1 / (farVal-nearVal);
Float invTMB = 1 / (top-bottom);
Float invRML = 1 / (right-left);
Matrix4x4 trafo(
2*nearVal*invRML, 0, (right+left)*invRML, 0,
0, 2*nearVal*invTMB, (top+bottom)*invTMB, 0,
0, 0, -(farVal + nearVal) * invFMN, -2*farVal*nearVal*invFMN,
0, 0, -1, 0
);
return Transform(trafo);
}
Spectrum sampleRayDifferential(RayDifferential &ray, const Point2 &pixelSample,
const Point2 &otherSample, Float timeSample) const {
ray.time = sampleTime(timeSample);
const Transform &trafo = m_worldTransform->eval(ray.time);
/* Compute the corresponding position on the
near plane (in local camera space) */
Point nearP = m_sampleToCamera.transformAffine(Point(
pixelSample.x * m_invResolution.x,
pixelSample.y * m_invResolution.y, 0.0f));
nearP.z = 0.0f;
ray.setOrigin(trafo.transformAffine(nearP));
ray.setDirection(normalize(trafo(Vector(0, 0, 1))));
ray.mint = m_nearClip;
ray.maxt = m_farClip;
ray.rxOrigin = trafo(nearP + m_dx);
ray.ryOrigin = trafo(nearP + m_dy);
ray.rxDirection = ray.ryDirection = ray.d;
ray.hasDifferentials = true;
return Spectrum(1.0f);
}
Spectrum samplePosition(PositionSamplingRecord &pRec,
const Point2 &sample, const Point2 *extra) const {
const Transform &trafo = m_worldTransform->eval(pRec.time);
Point2 aperturePos = warp::squareToUniformDiskConcentric(sample)
* m_apertureRadius;
pRec.p = trafo.transformAffine(
Point(aperturePos.x, aperturePos.y, 0.0f));
pRec.n = trafo(Vector(0.0f, 0.0f, 1.0f));
pRec.pdf = m_aperturePdf;
pRec.measure = EArea;
return Spectrum(1.0f);
}
Transform Transform::translate(const Vector &v) {
Matrix4x4 trafo(
1, 0, 0, v.x,
0, 1, 0, v.y,
0, 0, 1, v.z,
0, 0, 0, 1
);
Matrix4x4 invTrafo(
1, 0, 0, -v.x,
0, 1, 0, -v.y,
0, 0, 1, -v.z,
0, 0, 0, 1
);
return Transform(trafo, invTrafo);
}
Transform Transform::scale(const Vector &v) {
Matrix4x4 trafo(
v.x, 0, 0, 0,
0, v.y, 0, 0,
0, 0, v.z, 0,
0, 0, 0, 1
);
Matrix4x4 invTrafo(
1.0f/v.x, 0, 0, 0,
0, 1.0f/v.y, 0, 0,
0, 0, 1.0f/v.z, 0,
0, 0, 0, 1
);
return Transform(trafo, invTrafo);
}
// Transforms a shape with the current transformation matrix and
// returns the transformed shape
TopoDS_Shape CTiglTransformation::Transform(const TopoDS_Shape& shape) const
{
if (IsUniform()) {
gp_Trsf t;
t.SetValues(m_matrix[0][0], m_matrix[0][1], m_matrix[0][2], m_matrix[0][3],
m_matrix[1][0], m_matrix[1][1], m_matrix[1][2], m_matrix[1][3],
m_matrix[2][0], m_matrix[2][1], m_matrix[2][2], m_matrix[2][3]
#if OCC_VERSION_HEX >= VERSION_HEX_CODE(6,8,0)
);
#else
,1e-10, 1e-10);
#endif
BRepBuilderAPI_Transform trafo(shape, t);
return trafo.Shape();
}