Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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`, μ; ω, ν) = L1(ω, ν) δ(μ - ν), 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`, μ) = W1(ω, ν) δ(μ - ν), 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) L0j(x, ν) at the point `env.point` in case of light sources, or the corresponding function W0j(x, ν) in case of sensors.

  The returned value is the value of the probability density px 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

  L0(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
  L1(x, ω, ν) = L(x, ω, ν) / L0(x, ν)
  so that the radiance is split into
  L(x, ω, ν) = L0(x, ν) L1(x, ω, ν)
  Let oi and si 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 si(ν) f(oi, ν)
  is an unbiased estimate for the integral
  ∫ L0(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 W0(x, ν) and W1(x, ω, ν) are defined similarly to the case of light sources:

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

  Let px be the probability density used for the ray origin, then the field `originDensity` is set to px(oi) for each ray. For emitters which are concentrated at a single point (e.g., point lights) px 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 di and si denote the directions and spectra of the N generated rays (N = `rays.size`). Then, for every frequency ν the sum
  1 / N ∑i si(ν) f(di; ν)
  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`, μ; ω, ν) = L1(ω, ν) δ(μ - ν), 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`, μ) = W1(ω, ν) δ(μ - ν), 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ω(di). 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)

Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD