de.grogra.imp3d
Class Camera

java.lang.Object
  de.grogra.imp3d.CameraBase
      de.grogra.imp3d.Camera

All Implemented Interfaces:

Manageable, Shareable, Emitter, Scattering, Sensor

public class Camera
extends CameraBase
implements Shareable, Manageable, Sensor

Nested Class Summary

static class

Camera.Type

Field Summary

static Camera.Type	$TYPE
protected float	maxZ
static SCOType.Field	maxZ$FIELD
protected float	minZ
static SCOType.Field	minZ$FIELD
protected Projection	projection
static SCOType.Field	projection$FIELD
protected SharedObjectProvider	sop
protected Matrix4d	transformation
static SCOType.Field	transformation$FIELD

Fields inherited from interface de.grogra.ray.physics.Scattering

DELTA_FACTOR, IS_NON_OPAQUE, MIN_UNUSED_FLAG, NEEDS_NORMAL, NEEDS_POINT, NEEDS_TANGENTS, NEEDS_TRANSFORMATION, NEEDS_UV, RANDOM_RAYS_GENERATE_ORIGINS

Constructor Summary

Camera()

Camera(Projection p)

Method Summary

void	addReference(SharedObjectReference ref)
void	appendReferencesTo(java.util.List out)
double	completeRay(Environment env, Point3d vertex, Ray out)
float	computeBSDF(Environment env, Vector3f in, Spectrum specIn, Vector3f out, boolean adjoint, Spectrum bsdf) Evaluates bidirectional scattering distribution function for given input.
double	computeExitance(Environment env, Spectrum exitance) Evaluates the exitance function for given input.
static Camera	createBackView()
static Camera	createBottomView()
static Camera	createFrontView()
static Camera	createLeftView()
static Camera	createParallel()
static Camera	createPerspective()
static Camera	createRightView()
static Camera	createTopView()
void	fieldModified(PersistenceField field, int[] indices, Transaction t)
void	generateRandomOrigins(Environment env, RayList out, java.util.Random rnd) Pseudorandomly generates, for the given input, a set of origins for this emitter.
void	generateRandomRays(Environment env, Vector3f out, Spectrum specOut, RayList rays, boolean adjoint, java.util.Random rnd) Pseudorandomly generates, for the given input, a set of scattered rays.
int	getAverageColor() Returns an average color for the scattering entity.
int	getFlags()
ManageableType	getManageableType()
Projection	getProjection()
SharedObjectProvider	getProvider()
void	getRay(float x, float y, Point3d origin, Vector3d direction) Determines the ray which starts at the camera and goes through the specified point on the image plane of the camera.
float	getScaleAt(double x, double y, double z) Computes an estimate for the scaling factor from 3D world coordinates at (x, y, z) to 2D coordinates on the camera plane.
float	getScaleAt(float z) Computes an estimate for the scaling factor from view coordinates around a depth of z to 2D coordinates on the camera plane.
int	getStamp() Returns a stamp for this object.
Matrix4d	getTransformation()
float[]	getUVForVertex(Environment env, Point3d vertex)
void	getViewToClipTransformation(Matrix4d m) Computes the transformation from view coordinates (= camera coordinates, not world coordinates!)
Matrix4d	getWorldToViewTransformation() Returns the world-to-view transformation of this camera.
float	getZFar()
float	getZNear()
void	initProvider(SharedObjectProvider provider)
Manageable	manageableReadResolve()
java.lang.Object	manageableWriteReplace()
boolean	projectView(float px, float py, float pz, Tuple2f point2D, boolean checkClip)
boolean	projectWorld(double px, double py, double pz, Tuple2f point2D)
void	removeReference(SharedObjectReference ref)
void	setProjection(Projection value)
void	setTransformation(Matrix4d value)
void	setZFar(float maxZ)
void	setZNear(float minZ)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

$TYPE

public static final Camera.Type $TYPE

maxZ

protected float maxZ

maxZ$FIELD

public static final SCOType.Field maxZ$FIELD

minZ

protected float minZ

minZ$FIELD

public static final SCOType.Field minZ$FIELD

projection

protected Projection projection

projection$FIELD

public static final SCOType.Field projection$FIELD

sop

protected transient SharedObjectProvider sop

transformation

protected final Matrix4d transformation

transformation$FIELD

public static final SCOType.Field transformation$FIELD

Constructor Detail

Camera

public Camera()

Camera

public Camera(Projection p)

Method Detail

addReference

public void addReference(SharedObjectReference ref)

Specified by:

addReference in interface Shareable

appendReferencesTo

public void appendReferencesTo(java.util.List out)

Specified by:

appendReferencesTo in interface Shareable

completeRay

public double completeRay(Environment env,
                          Point3d vertex,
                          Ray out)

Specified by:

completeRay in interface Emitter

computeBSDF

public float computeBSDF(Environment env,
                         Vector3f in,
                         Spectrum specIn,
                         Vector3f out,
                         boolean adjoint,
                         Spectrum bsdf)

Description copied from interface: Scattering

Evaluates bidirectional scattering distribution function for given input.

The computed spectrum is an integral over the spectrum of the following product:

|cos θ| BSDF(ω_i, ν_i; ω_o, ν_o) where BSDF is the bidirectional scattering distribution function (= BRDF + BTDF) at the point env.point, ω_i the (negated) direction of the incoming light ray, ν_i the frequency where the incoming ray is sampled, ω_o the direction of the outgoing light ray, ν_o the frequency where the outgoing ray is sampled, and θ the angle between the surface normal and out.

If adjoint is false, in and out describe true light rays from light sources to sensors. In this case, ω_i = in, ω_o = out, and the integral is

bsdf(ν) = |cos θ| ∫ BSDF(in, ν_i; out, ν) specIn(ν_i) dν_i Otherwise, adjoint is true. in and out then describe importance rays (inverse light rays from sensors to light sources). In this case, ω_i = out, ω_o = in, and the integral is bsdf(ν) = |cos θ| ∫ BSDF(out, ν; in, ν_o) specIn(ν_o) dν_o

If this Scattering instance is in fact a Light source, adjoint is false, and the BSDF is defined as BSDF(in, μ; ω, ν) = L¹(ω, ν) δ(μ - ν), i.e., the directional distribution of the emitted radiance at env.point, see Emitter. In this case, in is not used.

If this Scattering instance is in fact a Sensor, adjoint is true, and the BSDF is defined as BSDF(ω, ν; in, μ) = W¹(ω, ν) δ(μ - ν), i.e., the directional distribution of the emitted importance at env.point, see Emitter. In this case, in is not used.

The computation should be physically valid. This excludes, e.g., ambient or emissive light contributions.

The returned value is the value of the probability density p_ω that would be calculated by Scattering.generateRandomRays(de.grogra.ray.physics.Environment, javax.vecmath.Vector3f, de.grogra.ray.physics.Spectrum, de.grogra.ray.util.RayList, boolean, java.util.Random) if the ray happened to be one of the randomly generated rays.

Specified by:

computeBSDF in interface Scattering

Parameters:

env - the environment for scattering

in - the (negated) direction unit vector of the incoming ray (i.e., pointing away from the surface)

specIn - the spectrum of the incoming ray

out - the direction unit vector of the outgoing ray (i.e., pointing away from the surface)

adjoint - light ray or importance ray?

bsdf - the computed spectrum of the outgoing ray will be placed in here

Returns:

the value of the probability density for the ray direction

computeExitance

public double computeExitance(Environment env,
                              Spectrum exitance)

Description copied from interface: Emitter

Evaluates the exitance function for given input. The computed value is the spectrum of the radiant exitance (emitted power per area) L⁰_j(x, ν) at the point env.point in case of light sources, or the corresponding function W⁰_j(x, ν) in case of sensors.

The returned value is the value of the probability density p_x that would be calculated by Emitter.generateRandomOrigins(de.grogra.ray.physics.Environment, de.grogra.ray.util.RayList, java.util.Random) if env.point happened to be one of the randomly generated origins.

Specified by:

computeExitance in interface Emitter

Parameters:

env - the environment for scattering

exitance - the exitance values will be placed in here

Returns:

the value of the probability density for the ray origin

createBackView

public static Camera createBackView()

createBottomView

public static Camera createBottomView()

createFrontView

public static Camera createFrontView()

createLeftView

public static Camera createLeftView()

createParallel

public static Camera createParallel()

createPerspective

public static Camera createPerspective()

createRightView

public static Camera createRightView()

createTopView

public static Camera createTopView()

fieldModified

public void fieldModified(PersistenceField field,
                          int[] indices,
                          Transaction t)

Specified by:

fieldModified in interface Manageable

generateRandomOrigins

public void generateRandomOrigins(Environment env,
                                  RayList out,
                                  java.util.Random rnd)

Description copied from interface: Emitter

Pseudorandomly generates, for the given input, a set of origins for this emitter. They are generated such that they can be used for Monte Carlo-based photon tracing algorithms in the following way.

At first, we consider the case where the emitter is in fact a light source. Let L(x, ω, ν) be the emitted spectral radiance for the frequency ν at the light's surface point x in direction ω. The radiant exitance (emitted spectral power per area) at x is defined as

L⁰(x, ν) = ∫ cos θ L(x, ω, ν) dω where θ is the angle between the surface normal and ω. Now the directional distribution of the emitted radiance at x can be described by the density L¹(x, ω, ν) = L(x, ω, ν) / L⁰(x, ν) so that the radiance is split into L(x, ω, ν) = L⁰(x, ν) L¹(x, ω, ν) Let o_i and s_i denote the origins and spectra of the N generated rays (N = rays.size). Then for a function f(x, ν) which is to be integrated over the light surface, the sum 1 / N ∑_i s_i(ν) f(o_i, ν) is an unbiased estimate for the integral ∫ L⁰(x, ν) f(x, ν) dA The integral ranges over the whole surface A of the light source. As a consequence, the spectrum of a ray is to be considered as the ray's radiant spectral power.

Now if the emitter is a sensor, let W(x, ω, ν) be the emitted spectral importance for frequency ν at the sensors's surface point x in direction ω. The quantities W⁰(x, ν) and W¹(x, ω, ν) are defined similarly to the case of light sources:

W⁰(x, ν) = ∫ cos θ W(x, ω, ν) dω
W(x, ω, ν) = W⁰(x) W¹(x, ω, ν) The formulas for light sources are valid for sensors if the L-quantites are replaced by the corresponding W-quantities.

Let p_x be the probability density used for the ray origin, then the field originDensity is set to p_x(o_i) for each ray. For emitters which are concentrated at a single point (e.g., point lights) p_x is not a regular function, the value originDensity will be set to a multiple of Scattering.DELTA_FACTOR.

The ray properties which are not mentioned in the given formulas are neither used nor modified. These are the direction and its density.

Specified by:

generateRandomOrigins in interface Emitter

Parameters:

env - the environment

out - the outgoing rays to be generated

rnd - pseudorandom generator

generateRandomRays

public void generateRandomRays(Environment env,
                               Vector3f out,
                               Spectrum specOut,
                               RayList rays,
                               boolean adjoint,
                               java.util.Random rnd)

Description copied from interface: Scattering

Pseudorandomly generates, for the given input, a set of scattered rays. The scattered rays are generated such that they can be used for a Monte Carlo integration of a function f(ω;ν) over cos θ BSDF(ω_i, ν_i; ω_o, ν_o) in the following way:

• If adjoint is false, out = ω_o describes the direction of an outgoing light ray. In this case, the integration is with respect to ω_i. Let g(ω, ν; out, μ) = BSDF(ω, ν; out, μ)
• Otherwise, adjoint is true. In this case, out = ω_i describes the direction of an outgoing importance ray (an inverse light ray). Now the integration is with respect to ω_o. Let g(ω, ν; out, μ) = BSDF(out, μ; ω, ν)

Let d_i and s_i denote the directions and spectra of the N generated rays (N = rays.size). Then, for every frequency ν the sum 1 / N ∑_i s_i(ν) f(d_i; ν) is an unbiased estimate for the integral ∫ cos θ f(ω; ν) g(ω, ν; out, μ) specOut(μ) dμ dω θ is the angle between the surface normal and ω. The domain of integration is the whole sphere, since the bidirectional scattering distribution includes both reflection and transmission (BSDF = BRDF + BTDF).

If this Scattering instance is in fact a Light source, adjoint is true, and the BSDF is defined as BSDF(out, μ; ω, ν) = L¹(ω, ν) δ(μ - ν), i.e., the directional distribution of the emitted radiance at env.point, see Emitter. In this case, out is not used.

If this Scattering instance is in fact a Sensor, adjoint is false, and the BSDF is defined as BSDF(ω, ν; out, μ) = W¹(ω, ν) δ(μ - ν), i.e., the directional distribution of the emitted importance at env.point, see Emitter. In this case, out is not used.

Let p_ω be the probability density used for the ray direction (measured with respect to solid angle ω), then the field directionDensity of the ray i is set to p_ω(d_i). For ideal specular reflection or transmission, or for directional lights or sensors, p_ω is not a regular function, the value directionDensity will be set to a multiple of Scattering.DELTA_FACTOR.

The ray properties which are not mentioned in the given formulas are neither used nor modified. These are the origin and its density.

Specified by:

generateRandomRays in interface Scattering

Parameters:

env - the environment for scattering

out - the direction unit vector of the outgoing ray (i.e., pointing away from the surface)

specOut - the spectrum of the outgoing ray

rays - the rays to be generated

adjoint - represents out a light ray or an importance ray?

rnd - pseudorandom generator

See Also:

Scattering.computeBSDF(de.grogra.ray.physics.Environment, javax.vecmath.Vector3f, de.grogra.ray.physics.Spectrum, javax.vecmath.Vector3f, boolean, de.grogra.ray.physics.Spectrum)

getAverageColor

public int getAverageColor()

Description copied from interface: Scattering

Returns an average color for the scattering entity. This color is used for simplified graphical representations of the corresponding objects.

Specified by:

getAverageColor in interface Scattering

Returns:

an average color in Java's default sRGB color space, encoded as an int (0xAARRGGBB).

getFlags

public int getFlags()

Specified by:

getFlags in interface Scattering

getManageableType

public ManageableType getManageableType()

Specified by:

getManageableType in interface Manageable

getProjection

public Projection getProjection()

getProvider

public SharedObjectProvider getProvider()

Specified by:

getProvider in interface Shareable

getRay

public void getRay(float x,
                   float y,
                   Point3d origin,
                   Vector3d direction)

Description copied from class: CameraBase

Determines the ray which starts at the camera and goes through the specified point on the image plane of the camera.

Specified by:

getRay in class CameraBase

Parameters:

x - the x-coordinate on the image plane

y - the y-coordinate on the image plane

origin - the origin of the ray, in world coordinates

direction - the direction of the ray, in world coordinates

getScaleAt

public float getScaleAt(double x,
                        double y,
                        double z)

Description copied from class: CameraBase

Computes an estimate for the scaling factor from 3D world coordinates at (x, y, z) to 2D coordinates on the camera plane.

Specified by:

getScaleAt in class CameraBase

Parameters:

x - x world coordinate

y - y world coordinate

z - z world coordinate

Returns:

scaling factor of camera projection at location

getScaleAt

public float getScaleAt(float z)

Description copied from class: CameraBase

Computes an estimate for the scaling factor from view coordinates around a depth of z to 2D coordinates on the camera plane.

Specified by:

getScaleAt in class CameraBase

Parameters:

z - z view coordinate

Returns:

scaling factor of camera projection at location

getStamp

public int getStamp()

Description copied from interface: Manageable

Returns a stamp for this object. Each modification to this object increments the stamp. The initial stamp is non-negative.

Specified by:

getStamp in interface Manageable

Returns:

a stamp

getTransformation

public Matrix4d getTransformation()

getUVForVertex

public float[] getUVForVertex(Environment env,
                              Point3d vertex)

Specified by:

getUVForVertex in interface Sensor

getViewToClipTransformation

public void getViewToClipTransformation(Matrix4d m)

Computes the transformation from view coordinates (= camera coordinates, not world coordinates!) to clip coordinates.

Parameters:

m - the transformation is placed in here

getWorldToViewTransformation

public Matrix4d getWorldToViewTransformation()

Description copied from class: CameraBase

Returns the world-to-view transformation of this camera. It transforms world coordinates to view coordinates (= camera coordinates).

Specified by:

getWorldToViewTransformation in class CameraBase

Returns:

world-to-view transformation

getZFar

public float getZFar()

Specified by:

getZFar in class CameraBase

getZNear

public float getZNear()

Specified by:

getZNear in class CameraBase

initProvider

public void initProvider(SharedObjectProvider provider)

Specified by:

initProvider in interface Shareable

manageableReadResolve

public Manageable manageableReadResolve()

Specified by:

manageableReadResolve in interface Manageable

manageableWriteReplace

public java.lang.Object manageableWriteReplace()

Specified by:

manageableWriteReplace in interface Manageable

projectView

public boolean projectView(float px,
                           float py,
                           float pz,
                           Tuple2f point2D,
                           boolean checkClip)

projectWorld

public boolean projectWorld(double px,
                            double py,
                            double pz,
                            Tuple2f point2D)

removeReference

public void removeReference(SharedObjectReference ref)

Specified by:

removeReference in interface Shareable

setProjection

public void setProjection(Projection value)

setTransformation

public void setTransformation(Matrix4d value)

setZFar

public void setZFar(float maxZ)

setZNear

public void setZNear(float minZ)