void verify(T&c) {
std::stringstream file;
ROOT::Reflex::Type type = ROOT::Reflex::Type::ByTypeInfo(typeid(T));
ROOT::Reflex::Object ob(type,&c);
// boost::archive::binary_oarchive oa(file);
boost::archive::text_oarchive oa(file);
oa << ob;
T co;
ROOT::Reflex::Object ib(type,&co);
boost::archive::text_iarchive ia(file);
ia >> ib;
if (co!=c) std::cout << "Error" << std::endl;
std::cout << file.str() << std::endl;
std::ostringstream xfile;
boost::archive::xml_oarchive ox(xfile);
ox << boost::serialization::make_nvp("A",ob);
std::cout << std::endl
<< xfile.str() << std::endl;
}
bool Sphere::IntersectP(const Ray &r, bool testAlphaTexture) const {
Float phi;
Point3f pHit;
// Transform _Ray_ to object space
Vector3f oErr, dErr;
Ray ray = (*WorldToObject)(r, &oErr, &dErr);
// Compute quadratic sphere coefficients
// Initialize _EFloat_ ray coordinate values
EFloat ox(ray.o.x, oErr.x), oy(ray.o.y, oErr.y), oz(ray.o.z, oErr.z);
EFloat dx(ray.d.x, dErr.x), dy(ray.d.y, dErr.y), dz(ray.d.z, dErr.z);
EFloat a = dx * dx + dy * dy + dz * dz;
EFloat b = 2 * (dx * ox + dy * oy + dz * oz);
EFloat c = ox * ox + oy * oy + oz * oz - EFloat(radius) * EFloat(radius);
// Solve quadratic equation for _t_ values
EFloat t0, t1;
if (!Quadratic(a, b, c, &t0, &t1)) return false;
// Check quadric shape _t0_ and _t1_ for nearest intersection
if (t0.UpperBound() > ray.tMax || t1.LowerBound() <= 0) return false;
EFloat tShapeHit = t0;
if (tShapeHit.LowerBound() <= 0) {
tShapeHit = t1;
if (tShapeHit.UpperBound() > ray.tMax) return false;
}
// Compute sphere hit position and $\phi$
pHit = ray((Float)tShapeHit);
// Refine sphere intersection point
pHit *= radius / Distance(pHit, Point3f(0, 0, 0));
if (pHit.x == 0 && pHit.y == 0) pHit.x = 1e-5f * radius;
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0) phi += 2 * Pi;
// Test sphere intersection against clipping parameters
if ((zMin > -radius && pHit.z < zMin) || (zMax < radius && pHit.z > zMax) ||
phi > phiMax) {
if (tShapeHit == t1) return false;
if (t1.UpperBound() > ray.tMax) return false;
tShapeHit = t1;
// Compute sphere hit position and $\phi$
pHit = ray((Float)tShapeHit);
// Refine sphere intersection point
pHit *= radius / Distance(pHit, Point3f(0, 0, 0));
if (pHit.x == 0 && pHit.y == 0) pHit.x = 1e-5f * radius;
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0) phi += 2 * Pi;
if ((zMin > -radius && pHit.z < zMin) ||
(zMax < radius && pHit.z > zMax) || phi > phiMax)
return false;
}
return true;
}
bool Cylinder::IntersectP(const Ray &r, bool testAlphaTexture) const {
Float phi;
Point3f pHit;
// Transform _Ray_ to object space
Vector3f oErr, dErr;
Ray ray = (*WorldToObject)(r, &oErr, &dErr);
// Compute quadratic cylinder coefficients
// Initialize _EFloat_ ray coordinate values
EFloat ox(ray.o.x, oErr.x), oy(ray.o.y, oErr.y), oz(ray.o.z, oErr.z);
EFloat dx(ray.d.x, dErr.x), dy(ray.d.y, dErr.y), dz(ray.d.z, dErr.z);
EFloat a = dx * dx + dy * dy;
EFloat b = 2 * (dx * ox + dy * oy);
EFloat c = ox * ox + oy * oy - EFloat(radius) * EFloat(radius);
// Solve quadratic equation for _t_ values
EFloat t0, t1;
if (!Quadratic(a, b, c, &t0, &t1)) return false;
// Check quadric shape _t0_ and _t1_ for nearest intersection
if (t0.UpperBound() > ray.tMax || t1.LowerBound() <= 0) return false;
EFloat tShapeHit = t0;
if (tShapeHit.LowerBound() <= 0) {
tShapeHit = t1;
if (tShapeHit.UpperBound() > ray.tMax) return false;
}
// Compute cylinder hit point and $\phi$
pHit = ray((Float)tShapeHit);
// Refine cylinder intersection point
Float hitRad = std::sqrt(pHit.x * pHit.x + pHit.y * pHit.y);
pHit.x *= radius / hitRad;
pHit.y *= radius / hitRad;
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0) phi += 2 * Pi;
// Test cylinder intersection against clipping parameters
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) {
if (tShapeHit == t1) return false;
tShapeHit = t1;
if (t1.UpperBound() > ray.tMax) return false;
// Compute cylinder hit point and $\phi$
pHit = ray((Float)tShapeHit);
// Refine cylinder intersection point
Float hitRad = std::sqrt(pHit.x * pHit.x + pHit.y * pHit.y);
pHit.x *= radius / hitRad;
pHit.y *= radius / hitRad;
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0) phi += 2 * Pi;
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) return false;
}
return true;
}
int
main (int argc, char *argv[])
{
struct bovid cow;
cow.red = 7.4;
cow.green = 6;
cow.blue = &cow;
ox (cow);
return 0;
}
bool Hyperboloid::IntersectP(const Ray &r) const {
Float phi, v;
Point3f pHit;
// Transform _Ray_ to object space
Vector3f oErr, dErr;
Ray ray = (*WorldToObject)(r, &oErr, &dErr);
// Compute quadratic hyperboloid coefficients
// Initialize _EFloat_ ray coordinate values
EFloat ox(ray.o.x, oErr.x), oy(ray.o.y, oErr.y), oz(ray.o.z, oErr.z);
EFloat dx(ray.d.x, dErr.x), dy(ray.d.y, dErr.y), dz(ray.d.z, dErr.z);
EFloat a = ah * dx * dx + ah * dy * dy - ch * dz * dz;
EFloat b = 2.f * (ah * dx * ox + ah * dy * oy - ch * dz * oz);
EFloat c = ah * ox * ox + ah * oy * oy - ch * oz * oz - 1.f;
// Solve quadratic equation for _t_ values
EFloat t0, t1;
if (!Quadratic(a, b, c, &t0, &t1)) return false;
// Check quadric shape _t0_ and _t1_ for nearest intersection
if (t0.UpperBound() > ray.tMax || t1.LowerBound() <= 0) return false;
EFloat tShapeHit = t0;
if (t0.LowerBound() <= 0) {
tShapeHit = t1;
if (tShapeHit.UpperBound() > ray.tMax) return false;
}
// Compute hyperboloid inverse mapping
pHit = ray((Float)tShapeHit);
v = (pHit.z - p1.z) / (p2.z - p1.z);
Point3f pr = (1 - v) * p1 + v * p2;
phi = std::atan2(pr.x * pHit.y - pHit.x * pr.y,
pHit.x * pr.x + pHit.y * pr.y);
if (phi < 0) phi += 2 * Pi;
// Test hyperboloid intersection against clipping parameters
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) {
if (tShapeHit == t1) return false;
tShapeHit = t1;
if (t1.UpperBound() > ray.tMax) return false;
// Compute hyperboloid inverse mapping
pHit = ray((Float)tShapeHit);
v = (pHit.z - p1.z) / (p2.z - p1.z);
Point3f pr = (1 - v) * p1 + v * p2;
phi = std::atan2(pr.x * pHit.y - pHit.x * pr.y,
pHit.x * pr.x + pHit.y * pr.y);
if (phi < 0) phi += 2 * Pi;
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) return false;
}
return true;
}
void caller (void)
{
struct bovid cow, calf;
cow.red = 7.4;
cow.green = 6;
cow.blue = &cow;
calf.red = 8.4;
calf.green = 5;
calf.blue = &cow;
ox (cow,4,calf,2);
return;
}
void *TextureBrick::tex_data(int c)
{
if (c >= 0 && data_[c])
{
unsigned char *ptr = (unsigned char *)(data_[c]->data);
long long offset = (long long)(oz()) *
(long long)(sx()) *
(long long)(sy()) +
(long long)(oy()) *
(long long)(sx()) +
(long long)(ox());
return ptr + offset * tex_type_size(tex_type(c));
}
else
return NULL;
}
bool Paraboloid::IntersectP(const Ray &r) const {
Float phi;
Point3f pHit;
// Transform _Ray_ to object space
Vector3f oErr, dErr;
Ray ray = (*WorldToObject)(r, &oErr, &dErr);
// Compute quadratic paraboloid coefficients
// Initialize _EFloat_ ray coordinate values
EFloat ox(ray.o.x, oErr.x), oy(ray.o.y, oErr.y), oz(ray.o.z, oErr.z);
EFloat dx(ray.d.x, dErr.x), dy(ray.d.y, dErr.y), dz(ray.d.z, dErr.z);
EFloat k = EFloat(zMax) / (EFloat(radius) * EFloat(radius));
EFloat a = k * (dx * dx + dy * dy);
EFloat b = 2.f * k * (dx * ox + dy * oy) - dz;
EFloat c = k * (ox * ox + oy * oy) - oz;
// Solve quadratic equation for _t_ values
EFloat t0, t1;
if (!Quadratic(a, b, c, &t0, &t1)) return false;
// Check quadric shape _t0_ and _t1_ for nearest intersection
if (t0.UpperBound() > ray.tMax || t1.LowerBound() <= 0) return false;
EFloat tShapeHit = t0;
if (tShapeHit.LowerBound() <= 0) {
tShapeHit = t1;
if (tShapeHit.UpperBound() > ray.tMax) return false;
}
// Compute paraboloid inverse mapping
pHit = ray((Float)tShapeHit);
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0.) phi += 2 * Pi;
// Test paraboloid intersection against clipping parameters
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) {
if (tShapeHit == t1) return false;
tShapeHit = t1;
if (t1.UpperBound() > ray.tMax) return false;
// Compute paraboloid inverse mapping
pHit = ray((Float)tShapeHit);
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0.) phi += 2 * Pi;
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) return false;
}
return true;
}
bool Hyperboloid::Intersect(const Ray &r, Float *tHit,
SurfaceInteraction *isect) const {
Float phi, v;
Point3f pHit;
// Transform _Ray_ to object space
Vector3f oErr, dErr;
Ray ray = (*WorldToObject)(r, &oErr, &dErr);
// Compute quadratic hyperboloid coefficients
// Initialize _EFloat_ ray coordinate values
EFloat ox(ray.o.x, oErr.x), oy(ray.o.y, oErr.y), oz(ray.o.z, oErr.z);
EFloat dx(ray.d.x, dErr.x), dy(ray.d.y, dErr.y), dz(ray.d.z, dErr.z);
EFloat a = ah * dx * dx + ah * dy * dy - ch * dz * dz;
EFloat b = 2.f * (ah * dx * ox + ah * dy * oy - ch * dz * oz);
EFloat c = ah * ox * ox + ah * oy * oy - ch * oz * oz - 1.f;
// Solve quadratic equation for _t_ values
EFloat t0, t1;
if (!Quadratic(a, b, c, &t0, &t1)) return false;
// Check quadric shape _t0_ and _t1_ for nearest intersection
if (t0.UpperBound() > ray.tMax || t1.LowerBound() <= 0) return false;
EFloat tShapeHit = t0;
if (t0.LowerBound() <= 0) {
tShapeHit = t1;
if (tShapeHit.UpperBound() > ray.tMax) return false;
}
// Compute hyperboloid inverse mapping
pHit = ray((Float)tShapeHit);
v = (pHit.z - p1.z) / (p2.z - p1.z);
Point3f pr = (1 - v) * p1 + v * p2;
phi = std::atan2(pr.x * pHit.y - pHit.x * pr.y,
pHit.x * pr.x + pHit.y * pr.y);
if (phi < 0) phi += 2 * Pi;
// Test hyperboloid intersection against clipping parameters
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) {
if (tShapeHit == t1) return false;
tShapeHit = t1;
if (t1.UpperBound() > ray.tMax) return false;
// Compute hyperboloid inverse mapping
pHit = ray((Float)tShapeHit);
v = (pHit.z - p1.z) / (p2.z - p1.z);
Point3f pr = (1 - v) * p1 + v * p2;
phi = std::atan2(pr.x * pHit.y - pHit.x * pr.y,
pHit.x * pr.x + pHit.y * pr.y);
if (phi < 0) phi += 2 * Pi;
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) return false;
}
// Compute parametric representation of hyperboloid hit
Float u = phi / phiMax;
// Compute hyperboloid $\dpdu$ and $\dpdv$
Float cosPhi = std::cos(phi), sinPhi = std::sin(phi);
Vector3f dpdu(-phiMax * pHit.y, phiMax * pHit.x, 0.);
Vector3f dpdv((p2.x - p1.x) * cosPhi - (p2.y - p1.y) * sinPhi,
(p2.x - p1.x) * sinPhi + (p2.y - p1.y) * cosPhi, p2.z - p1.z);
// Compute hyperboloid $\dndu$ and $\dndv$
Vector3f d2Pduu = -phiMax * phiMax * Vector3f(pHit.x, pHit.y, 0);
Vector3f d2Pduv = phiMax * Vector3f(-dpdv.y, dpdv.x, 0.);
Vector3f d2Pdvv(0, 0, 0);
// Compute coefficients for fundamental forms
Float E = Dot(dpdu, dpdu);
Float F = Dot(dpdu, dpdv);
Float G = Dot(dpdv, dpdv);
Vector3f N = Normalize(Cross(dpdu, dpdv));
Float e = Dot(N, d2Pduu);
Float f = Dot(N, d2Pduv);
Float g = Dot(N, d2Pdvv);
// Compute $\dndu$ and $\dndv$ from fundamental form coefficients
Float invEGF2 = 1 / (E * G - F * F);
Normal3f dndu = Normal3f((f * F - e * G) * invEGF2 * dpdu +
(e * F - f * E) * invEGF2 * dpdv);
Normal3f dndv = Normal3f((g * F - f * G) * invEGF2 * dpdu +
(f * F - g * E) * invEGF2 * dpdv);
// Compute error bounds for hyperboloid intersection
// Compute error bounds for intersection computed with ray equation
EFloat px = ox + tShapeHit * dx;
EFloat py = oy + tShapeHit * dy;
EFloat pz = oz + tShapeHit * dz;
Vector3f pError = Vector3f(px.GetAbsoluteError(), py.GetAbsoluteError(),
pz.GetAbsoluteError());
// Initialize _SurfaceInteraction_ from parametric information
*isect = (*ObjectToWorld)(SurfaceInteraction(pHit, pError, Point2f(u, v),
-ray.d, dpdu, dpdv, dndu, dndv,
ray.time, this));
*tHit = (Float)tShapeHit;
return true;
}
void PSSMLightShadowMap::setShaderParameters(GFXShaderConstBuffer* params, LightingShaderConstants* lsc)
{
PROFILE_SCOPE( PSSMLightShadowMap_setShaderParameters );
AssertFatal(mNumSplits > 0 && mNumSplits <= MAX_SPLITS,
avar("PSSMLightShadowMap::_setNumSplits() - Splits must be between 1 and %d!", MAX_SPLITS));
if ( lsc->mTapRotationTexSC->isValid() )
GFX->setTexture( lsc->mTapRotationTexSC->getSamplerRegister(),
SHADOWMGR->getTapRotationTex() );
const ShadowMapParams *p = mLight->getExtended<ShadowMapParams>();
Point4F sx(Point4F::Zero),
sy(Point4F::Zero),
ox(Point4F::Zero),
oy(Point4F::Zero),
aXOff(Point4F::Zero),
aYOff(Point4F::Zero);
for (U32 i = 0; i < mNumSplits; i++)
{
sx[i] = mScaleProj[i].x;
sy[i] = mScaleProj[i].y;
ox[i] = mOffsetProj[i].x;
oy[i] = mOffsetProj[i].y;
}
Point2F shadowMapAtlas;
if (mNumSplits < 4)
{
shadowMapAtlas.x = 1.0f / (F32)mNumSplits;
shadowMapAtlas.y = 1.0f;
// 1xmNumSplits
for (U32 i = 0; i < mNumSplits; i++)
aXOff[i] = (F32)i * shadowMapAtlas.x;
}
else
{
shadowMapAtlas.set(0.5f, 0.5f);
// 2x2
for (U32 i = 0; i < mNumSplits; i++)
{
if (i == 1 || i == 3)
aXOff[i] = 0.5f;
if (i > 1)
aYOff[i] = 0.5f;
}
}
params->setSafe(lsc->mScaleXSC, sx);
params->setSafe(lsc->mScaleYSC, sy);
params->setSafe(lsc->mOffsetXSC, ox);
params->setSafe(lsc->mOffsetYSC, oy);
params->setSafe(lsc->mAtlasXOffsetSC, aXOff);
params->setSafe(lsc->mAtlasYOffsetSC, aYOff);
params->setSafe(lsc->mAtlasScaleSC, shadowMapAtlas);
Point4F lightParams( mLight->getRange().x, p->overDarkFactor.x, 0.0f, 0.0f );
params->setSafe( lsc->mLightParamsSC, lightParams );
params->setSafe( lsc->mFarPlaneScalePSSM, mFarPlaneScalePSSM);
Point2F fadeStartLength(p->fadeStartDist, 0.0f);
if (fadeStartLength.x == 0.0f)
{
// By default, lets fade the last half of the last split.
fadeStartLength.x = (mSplitDist[mNumSplits-1] + mSplitDist[mNumSplits]) / 2.0f;
}
fadeStartLength.y = 1.0f / (mSplitDist[mNumSplits] - fadeStartLength.x);
params->setSafe( lsc->mFadeStartLength, fadeStartLength);
params->setSafe( lsc->mOverDarkFactorPSSM, p->overDarkFactor);
// The softness is a factor of the texel size.
params->setSafe( lsc->mShadowSoftnessConst, p->shadowSoftness * ( 1.0f / mTexSize ) );
}
int *caller (void)
{
int b = 10;
return ox (&a, &b);
}
Py::Object
_image_module::from_images(const Py::Tuple& args) {
_VERBOSE("_image_module::from_images");
args.verify_length(3);
size_t numrows = Py::Int(args[0]);
size_t numcols = Py::Int(args[1]);
Py::SeqBase<Py::Object> tups = args[2];
size_t N = tups.length();
if (N==0)
throw Py::RuntimeError("Empty list of images");
Py::Tuple tup;
size_t ox(0), oy(0), thisx(0), thisy(0);
//copy image 0 output buffer into return images output buffer
Image* imo = new Image;
imo->rowsOut = numrows;
imo->colsOut = numcols;
size_t NUMBYTES(numrows * numcols * imo->BPP);
imo->bufferOut = new agg::int8u[NUMBYTES];
if (imo->bufferOut==NULL) //todo: also handle allocation throw
throw Py::MemoryError("_image_module::from_images could not allocate memory");
imo->rbufOut = new agg::rendering_buffer;
imo->rbufOut->attach(imo->bufferOut, imo->colsOut, imo->rowsOut, imo->colsOut * imo->BPP);
pixfmt pixf(*imo->rbufOut);
renderer_base rb(pixf);
for (size_t imnum=0; imnum< N; imnum++) {
tup = Py::Tuple(tups[imnum]);
Image* thisim = static_cast<Image*>(tup[0].ptr());
if (imnum==0)
rb.clear(thisim->bg);
ox = Py::Int(tup[1]);
oy = Py::Int(tup[2]);
size_t ind=0;
for (size_t j=0; j<thisim->rowsOut; j++) {
for (size_t i=0; i<thisim->colsOut; i++) {
thisx = i+ox;
thisy = j+oy;
if (thisx<0 || thisx>=numcols || thisy<0 || thisy>=numrows) {
ind +=4;
continue;
}
pixfmt::color_type p;
p.r = *(thisim->bufferOut+ind++);
p.g = *(thisim->bufferOut+ind++);
p.b = *(thisim->bufferOut+ind++);
p.a = *(thisim->bufferOut+ind++);
pixf.blend_pixel(thisx, thisy, p, 255);
}
}
}
return Py::asObject(imo);
}
bool Sphere::Intersect(const Ray &r, Float *tHit, SurfaceInteraction *isect,
bool testAlphaTexture) const {
Float phi;
Point3f pHit;
// Transform _Ray_ to object space
Vector3f oErr, dErr;
Ray ray = (*WorldToObject)(r, &oErr, &dErr);
// Compute quadratic sphere coefficients
// Initialize _EFloat_ ray coordinate values
EFloat ox(ray.o.x, oErr.x), oy(ray.o.y, oErr.y), oz(ray.o.z, oErr.z);
EFloat dx(ray.d.x, dErr.x), dy(ray.d.y, dErr.y), dz(ray.d.z, dErr.z);
EFloat a = dx * dx + dy * dy + dz * dz;
EFloat b = 2 * (dx * ox + dy * oy + dz * oz);
EFloat c = ox * ox + oy * oy + oz * oz - EFloat(radius) * EFloat(radius);
// Solve quadratic equation for _t_ values
EFloat t0, t1;
if (!Quadratic(a, b, c, &t0, &t1)) return false;
// Check quadric shape _t0_ and _t1_ for nearest intersection
if (t0.UpperBound() > ray.tMax || t1.LowerBound() <= 0) return false;
EFloat tShapeHit = t0;
if (tShapeHit.LowerBound() <= 0) {
tShapeHit = t1;
if (tShapeHit.UpperBound() > ray.tMax) return false;
}
// Compute sphere hit position and $\phi$
pHit = ray((Float)tShapeHit);
// Refine sphere intersection point
pHit *= radius / Distance(pHit, Point3f(0, 0, 0));
if (pHit.x == 0 && pHit.y == 0) pHit.x = 1e-5f * radius;
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0) phi += 2 * Pi;
// Test sphere intersection against clipping parameters
if ((zMin > -radius && pHit.z < zMin) || (zMax < radius && pHit.z > zMax) ||
phi > phiMax) {
if (tShapeHit == t1) return false;
if (t1.UpperBound() > ray.tMax) return false;
tShapeHit = t1;
// Compute sphere hit position and $\phi$
pHit = ray((Float)tShapeHit);
// Refine sphere intersection point
pHit *= radius / Distance(pHit, Point3f(0, 0, 0));
if (pHit.x == 0 && pHit.y == 0) pHit.x = 1e-5f * radius;
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0) phi += 2 * Pi;
if ((zMin > -radius && pHit.z < zMin) ||
(zMax < radius && pHit.z > zMax) || phi > phiMax)
return false;
}
// Find parametric representation of sphere hit
Float u = phi / phiMax;
Float theta = std::acos(Clamp(pHit.z / radius, -1, 1));
Float v = (theta - thetaMin) / (thetaMax - thetaMin);
// Compute sphere $\dpdu$ and $\dpdv$
Float zRadius = std::sqrt(pHit.x * pHit.x + pHit.y * pHit.y);
Float invZRadius = 1 / zRadius;
Float cosPhi = pHit.x * invZRadius;
Float sinPhi = pHit.y * invZRadius;
Vector3f dpdu(-phiMax * pHit.y, phiMax * pHit.x, 0);
Vector3f dpdv =
(thetaMax - thetaMin) *
Vector3f(pHit.z * cosPhi, pHit.z * sinPhi, -radius * std::sin(theta));
// Compute sphere $\dndu$ and $\dndv$
Vector3f d2Pduu = -phiMax * phiMax * Vector3f(pHit.x, pHit.y, 0);
Vector3f d2Pduv =
(thetaMax - thetaMin) * pHit.z * phiMax * Vector3f(-sinPhi, cosPhi, 0.);
Vector3f d2Pdvv = -(thetaMax - thetaMin) * (thetaMax - thetaMin) *
Vector3f(pHit.x, pHit.y, pHit.z);
// Compute coefficients for fundamental forms
Float E = Dot(dpdu, dpdu);
Float F = Dot(dpdu, dpdv);
Float G = Dot(dpdv, dpdv);
Vector3f N = Normalize(Cross(dpdu, dpdv));
Float e = Dot(N, d2Pduu);
Float f = Dot(N, d2Pduv);
Float g = Dot(N, d2Pdvv);
// Compute $\dndu$ and $\dndv$ from fundamental form coefficients
Float invEGF2 = 1 / (E * G - F * F);
Normal3f dndu = Normal3f((f * F - e * G) * invEGF2 * dpdu +
(e * F - f * E) * invEGF2 * dpdv);
Normal3f dndv = Normal3f((g * F - f * G) * invEGF2 * dpdu +
(f * F - g * E) * invEGF2 * dpdv);
// Compute error bounds for sphere intersection
Vector3f pError = gamma(5) * Abs((Vector3f)pHit);
// Initialize _SurfaceInteraction_ from parametric information
*isect = (*ObjectToWorld)(SurfaceInteraction(pHit, pError, Point2f(u, v),
-ray.d, dpdu, dpdv, dndu, dndv,
ray.time, this));
// Update _tHit_ for quadric intersection
*tHit = (Float)tShapeHit;
return true;
}
XSECCryptoKey * InteropResolver::resolveKey(DSIGKeyInfoList * lst) {
// First check if this has an X509 cert + an X509 CRL
const XMLCh * b64cert = NULL;
const XMLCh * b64crl = NULL;
int lstSize = (int) lst->getSize();
for (int i = 0; i < lstSize; ++i) {
DSIGKeyInfo * ki;
ki = lst->item(i);
const XMLCh * rawuri;
if (ki->getKeyInfoType() == DSIGKeyInfo::KEYINFO_X509) {
DSIGKeyInfoX509 * kix509 = static_cast<DSIGKeyInfoX509 *>(ki);
if ((rawuri = kix509->getRawRetrievalURI()) != NULL) {
// We have a raw certificate by de-reference
// Assume it is just a file dereference and open the cert
return openCertURI(rawuri);
}
if (kix509->getCertificateListSize() == 1) {
b64cert = kix509->getCertificateItem(0);
}
if (b64crl == NULL) {
b64crl = kix509->getX509CRL();
}
}
else if (ki->getKeyInfoType() == DSIGKeyInfo::KEYINFO_NAME) {
DSIGKeyInfoName * kn = static_cast<DSIGKeyInfoName *>(ki);
if (kn->getKeyName() != NULL) {
static XMLCh certStr[] = {
XERCES_CPP_NAMESPACE_QUALIFIER chLatin_c,
XERCES_CPP_NAMESPACE_QUALIFIER chLatin_e,
XERCES_CPP_NAMESPACE_QUALIFIER chLatin_r,
XERCES_CPP_NAMESPACE_QUALIFIER chLatin_t,
XERCES_CPP_NAMESPACE_QUALIFIER chLatin_s,
XERCES_CPP_NAMESPACE_QUALIFIER chForwardSlash,
XERCES_CPP_NAMESPACE_QUALIFIER chNull
};
static XMLCh extStr[] = {
XERCES_CPP_NAMESPACE_QUALIFIER chPeriod,
XERCES_CPP_NAMESPACE_QUALIFIER chLatin_c,
XERCES_CPP_NAMESPACE_QUALIFIER chLatin_r,
XERCES_CPP_NAMESPACE_QUALIFIER chLatin_t,
XERCES_CPP_NAMESPACE_QUALIFIER chNull
};
safeBuffer fname;
fname = certStr;
fname.sbXMLChCat(kn->getKeyName());
fname.sbXMLChCat(extStr);
fname.sbStrlwr();
return openCertURI(fname.rawXMLChBuffer());
}
}
}
if (b64cert != NULL && b64crl != NULL) {
// We have a certificate and a crl, lets get the cert and check in the crl
OpenSSLCryptoBase64 b64;
char * transb64cert = XMLString::transcode(b64cert);
unsigned char * x509buf = new unsigned char[strlen(transb64cert)];
ArrayJanitor<unsigned char> j_x509buf(x509buf);
int x509bufLen;
X509 *x;
b64.decodeInit();
x509bufLen = b64.decode((unsigned char *) transb64cert, (unsigned int) strlen(transb64cert), x509buf, (unsigned int) strlen(transb64cert));
x509bufLen += b64.decodeFinish(&x509buf[x509bufLen], (unsigned int) strlen(transb64cert) - x509bufLen);
XSEC_RELEASE_XMLCH(transb64cert);
if (x509bufLen > 0) {
#if defined(XSEC_OPENSSL_D2IX509_CONST_BUFFER)
x = d2i_X509(NULL, (const unsigned char **) (&x509buf), x509bufLen
);
#else
x = d2i_X509(NULL, &x509buf, x509bufLen);
#endif
}
else
return NULL; // Something has gone wrong
if (x == NULL)
return NULL;
// Now the CRL
char * transb64crl = XMLString::transcode(b64crl);
unsigned char * crlbuf = new unsigned char[strlen(transb64crl)];
ArrayJanitor<unsigned char> j_crlbuf(crlbuf);
int crlbufLen;
X509_CRL * c;
b64.decodeInit();
crlbufLen = b64.decode((unsigned char*) transb64crl, (unsigned int) strlen(transb64crl), crlbuf, (unsigned int) strlen(transb64crl));
crlbufLen += b64.decodeFinish(&crlbuf[crlbufLen], (unsigned int) strlen(transb64crl) - crlbufLen);
XSEC_RELEASE_XMLCH(transb64crl);
if (crlbufLen > 0) {
#if defined(XSEC_OPENSSL_D2IX509_CONST_BUFFER)
c = d2i_X509_CRL(NULL, (const unsigned char **) (&crlbuf), crlbufLen);
#else
c = d2i_X509_CRL(NULL, &crlbuf, crlbufLen);
#endif
}
else
return NULL; // Something has gone wrong
if (c == NULL)
return NULL;
// Now check if the cert is in the CRL (code lifted from OpenSSL x509_vfy.c
int idx;
X509_REVOKED rtmp;
/* Look for serial number of certificate in CRL */
rtmp.serialNumber = X509_get_serialNumber(x);
idx = sk_X509_REVOKED_find(c->crl->revoked, &rtmp);
/* Not found: OK */
if(idx != -1) {
std::cerr << "Warning - certificate revoked in attached CRL" << std::endl;
}
OpenSSLCryptoX509 ox(x);
X509_free(x);
X509_CRL_free(c);
return ox.clonePublicKey();
}
// Do a run through each match in the directory
while (m_searchFinished == false) {
X509 * x = nextFile2Cert();
if (x != NULL) {
if (checkMatch(lst, x)) {
OpenSSLCryptoX509 ox(x);
X509_free(x);
return ox.clonePublicKey();
}
}
X509_free(x);
}
return false;
}
void distanceTransform::eightSEDFiltering(channel &chnl,
matrix<point> &dist)const{
//create all masks
point mask0[] = { point(-1, 0) };
sedMask xo(mask0, 1);
point mask1[] = { point(-1,-1), point(0,-1), point(1,-1), point(-1, 0) };
sedMask xxxxo(mask1, 4);
point mask2[] = { point(-1, -1), point(0, -1), point(-1, 0) };
sedMask xxxo(mask2, 3);
point mask3[] = { point(0, -1), point(1, -1) };
sedMask xxo(mask3, 2);
point mask4[] = { point(1, 0) };
sedMask ox(mask4, 1);
point mask5[] = { point(1, 0), point(-1, 1), point(0, 1), point(1, 1) };
sedMask oxxxx(mask5, 4);
point mask6[] = { point(1, 0), point(0, 1), point(1, 1) };
sedMask oxxx(mask6, 3);
point mask7[] = { point(-1, 1), point(0, 1) };
sedMask oxx(mask7, 2);
//filter the picture
point pos;
pos.y = 0;
//first row
for(pos.x = 1; pos.x < chnl.columns(); ++pos.x)
xo.filter(dist, pos);
for(pos.x = chnl.columns() - 2; pos.x >= 0; --pos.x)
ox.filter(dist, pos);
for(pos.y = 1; pos.y < chnl.rows(); ++pos.y){
pos.x = 0;
//step up
xxo.filter(dist, pos);
for(pos.x = 1; pos.x < chnl.columns() - 1; ++pos.x)
xxxxo.filter(dist, pos);
xxxo.filter(dist, pos);
for(pos.x = chnl.columns() - 2; pos.x >= 0; --pos.x)
ox.filter(dist, pos);
}
//and now filter the picture in the opposite direction
pos.y = chnl.rows() - 1;
//last row
for(pos.x = chnl.columns() - 2; pos.x >= 0; --pos.x)
ox.filter(dist, pos);
for(pos.x = 1; pos.x < chnl.columns(); ++pos.x)
xo.filter(dist, pos);
for(pos.y = chnl.rows() - 2; pos.y >= 0; --pos.y){
pos.x = chnl.columns() - 1;
//step down
oxx.filter(dist, pos);
for(pos.x = chnl.columns() - 2; pos.x > 0; --pos.x)
oxxxx.filter(dist, pos);
oxxx.filter(dist, pos);
for(pos.x = 1; pos.x < chnl.columns() - 1; ++pos.x)
xo.filter(dist, pos);
}
}
bool Cylinder::Intersect(const Ray &r, Float *tHit, SurfaceInteraction *isect,
bool testAlphaTexture) const {
Float phi;
Point3f pHit;
// Transform _Ray_ to object space
Vector3f oErr, dErr;
Ray ray = (*WorldToObject)(r, &oErr, &dErr);
// Compute quadratic cylinder coefficients
// Initialize _EFloat_ ray coordinate values
EFloat ox(ray.o.x, oErr.x), oy(ray.o.y, oErr.y), oz(ray.o.z, oErr.z);
EFloat dx(ray.d.x, dErr.x), dy(ray.d.y, dErr.y), dz(ray.d.z, dErr.z);
EFloat a = dx * dx + dy * dy;
EFloat b = 2 * (dx * ox + dy * oy);
EFloat c = ox * ox + oy * oy - EFloat(radius) * EFloat(radius);
// Solve quadratic equation for _t_ values
EFloat t0, t1;
if (!Quadratic(a, b, c, &t0, &t1)) return false;
// Check quadric shape _t0_ and _t1_ for nearest intersection
if (t0.UpperBound() > ray.tMax || t1.LowerBound() <= 0) return false;
EFloat tShapeHit = t0;
if (tShapeHit.LowerBound() <= 0) {
tShapeHit = t1;
if (tShapeHit.UpperBound() > ray.tMax) return false;
}
// Compute cylinder hit point and $\phi$
pHit = ray((Float)tShapeHit);
// Refine cylinder intersection point
Float hitRad = std::sqrt(pHit.x * pHit.x + pHit.y * pHit.y);
pHit.x *= radius / hitRad;
pHit.y *= radius / hitRad;
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0) phi += 2 * Pi;
// Test cylinder intersection against clipping parameters
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) {
if (tShapeHit == t1) return false;
tShapeHit = t1;
if (t1.UpperBound() > ray.tMax) return false;
// Compute cylinder hit point and $\phi$
pHit = ray((Float)tShapeHit);
// Refine cylinder intersection point
Float hitRad = std::sqrt(pHit.x * pHit.x + pHit.y * pHit.y);
pHit.x *= radius / hitRad;
pHit.y *= radius / hitRad;
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0) phi += 2 * Pi;
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) return false;
}
// Find parametric representation of cylinder hit
Float u = phi / phiMax;
Float v = (pHit.z - zMin) / (zMax - zMin);
// Compute cylinder $\dpdu$ and $\dpdv$
Vector3f dpdu(-phiMax * pHit.y, phiMax * pHit.x, 0);
Vector3f dpdv(0, 0, zMax - zMin);
// Compute cylinder $\dndu$ and $\dndv$
Vector3f d2Pduu = -phiMax * phiMax * Vector3f(pHit.x, pHit.y, 0);
Vector3f d2Pduv(0, 0, 0), d2Pdvv(0, 0, 0);
// Compute coefficients for fundamental forms
Float E = Dot(dpdu, dpdu);
Float F = Dot(dpdu, dpdv);
Float G = Dot(dpdv, dpdv);
Vector3f N = Normalize(Cross(dpdu, dpdv));
Float e = Dot(N, d2Pduu);
Float f = Dot(N, d2Pduv);
Float g = Dot(N, d2Pdvv);
// Compute $\dndu$ and $\dndv$ from fundamental form coefficients
Float invEGF2 = 1 / (E * G - F * F);
Normal3f dndu = Normal3f((f * F - e * G) * invEGF2 * dpdu +
(e * F - f * E) * invEGF2 * dpdv);
Normal3f dndv = Normal3f((g * F - f * G) * invEGF2 * dpdu +
(f * F - g * E) * invEGF2 * dpdv);
// Compute error bounds for cylinder intersection
Vector3f pError = gamma(3) * Abs(Vector3f(pHit.x, pHit.y, 0));
// Initialize _SurfaceInteraction_ from parametric information
*isect = (*ObjectToWorld)(SurfaceInteraction(pHit, pError, Point2f(u, v),
-ray.d, dpdu, dpdv, dndu, dndv,
ray.time, this));
// Update _tHit_ for quadric intersection
*tHit = (Float)tShapeHit;
return true;
}
bool Paraboloid::Intersect(const Ray &r, Float *tHit,
SurfaceInteraction *isect) const {
Float phi;
Point3f pHit;
// Transform _Ray_ to object space
Vector3f oErr, dErr;
Ray ray = (*WorldToObject)(r, &oErr, &dErr);
// Compute quadratic paraboloid coefficients
// Initialize _EFloat_ ray coordinate values
EFloat ox(ray.o.x, oErr.x), oy(ray.o.y, oErr.y), oz(ray.o.z, oErr.z);
EFloat dx(ray.d.x, dErr.x), dy(ray.d.y, dErr.y), dz(ray.d.z, dErr.z);
EFloat k = EFloat(zMax) / (EFloat(radius) * EFloat(radius));
EFloat a = k * (dx * dx + dy * dy);
EFloat b = 2.f * k * (dx * ox + dy * oy) - dz;
EFloat c = k * (ox * ox + oy * oy) - oz;
// Solve quadratic equation for _t_ values
EFloat t0, t1;
if (!Quadratic(a, b, c, &t0, &t1)) return false;
// Check quadric shape _t0_ and _t1_ for nearest intersection
if (t0.UpperBound() > ray.tMax || t1.LowerBound() <= 0) return false;
EFloat tShapeHit = t0;
if (tShapeHit.LowerBound() <= 0) {
tShapeHit = t1;
if (tShapeHit.UpperBound() > ray.tMax) return false;
}
// Compute paraboloid inverse mapping
pHit = ray((Float)tShapeHit);
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0.) phi += 2 * Pi;
// Test paraboloid intersection against clipping parameters
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) {
if (tShapeHit == t1) return false;
tShapeHit = t1;
if (t1.UpperBound() > ray.tMax) return false;
// Compute paraboloid inverse mapping
pHit = ray((Float)tShapeHit);
phi = std::atan2(pHit.y, pHit.x);
if (phi < 0.) phi += 2 * Pi;
if (pHit.z < zMin || pHit.z > zMax || phi > phiMax) return false;
}
// Find parametric representation of paraboloid hit
Float u = phi / phiMax;
Float v = (pHit.z - zMin) / (zMax - zMin);
// Compute paraboloid $\dpdu$ and $\dpdv$
Vector3f dpdu(-phiMax * pHit.y, phiMax * pHit.x, 0.);
Vector3f dpdv = (zMax - zMin) *
Vector3f(pHit.x / (2 * pHit.z), pHit.y / (2 * pHit.z), 1.);
// Compute paraboloid $\dndu$ and $\dndv$
Vector3f d2Pduu = -phiMax * phiMax * Vector3f(pHit.x, pHit.y, 0);
Vector3f d2Pduv =
(zMax - zMin) * phiMax *
Vector3f(-pHit.y / (2 * pHit.z), pHit.x / (2 * pHit.z), 0);
Vector3f d2Pdvv = -(zMax - zMin) * (zMax - zMin) *
Vector3f(pHit.x / (4 * pHit.z * pHit.z),
pHit.y / (4 * pHit.z * pHit.z), 0.);
// Compute coefficients for fundamental forms
Float E = Dot(dpdu, dpdu);
Float F = Dot(dpdu, dpdv);
Float G = Dot(dpdv, dpdv);
Vector3f N = Normalize(Cross(dpdu, dpdv));
Float e = Dot(N, d2Pduu);
Float f = Dot(N, d2Pduv);
Float g = Dot(N, d2Pdvv);
// Compute $\dndu$ and $\dndv$ from fundamental form coefficients
Float invEGF2 = 1 / (E * G - F * F);
Normal3f dndu = Normal3f((f * F - e * G) * invEGF2 * dpdu +
(e * F - f * E) * invEGF2 * dpdv);
Normal3f dndv = Normal3f((g * F - f * G) * invEGF2 * dpdu +
(f * F - g * E) * invEGF2 * dpdv);
// Compute error bounds for paraboloid intersection
// Compute error bounds for intersection computed with ray equation
EFloat px = ox + tShapeHit * dx;
EFloat py = oy + tShapeHit * dy;
EFloat pz = oz + tShapeHit * dz;
Vector3f pError = Vector3f(px.GetAbsoluteError(), py.GetAbsoluteError(),
pz.GetAbsoluteError());
// Initialize _SurfaceInteraction_ from parametric information
*isect = (*ObjectToWorld)(SurfaceInteraction(pHit, pError, Point2f(u, v),
-ray.d, dpdu, dpdv, dndu, dndv,
ray.time, this));
*tHit = (Float)tShapeHit;
return true;
}
