Module imp3d

Class Camera

All Implemented Interfaces:
Manageable, Shareable, Emitter, Scattering, Sensor

public class Camera extends CameraBase implements Shareable, Manageable, Sensor
  • Field Details

    • minZ

      protected float minZ
    • maxZ

      protected float maxZ
    • projection

      protected Projection projection
    • transformation

      protected final Matrix4d transformation
    • $TYPE

      public static final Camera.Type $TYPE
    • minZ$FIELD

      public static final SCOType.Field minZ$FIELD
    • maxZ$FIELD

      public static final SCOType.Field maxZ$FIELD
    • projection$FIELD

      public static final SCOType.Field projection$FIELD
    • transformation$FIELD

      public static final SCOType.Field transformation$FIELD
    • sop

      protected transient SharedObjectProvider sop
  • Constructor Details

    • Camera

      public Camera()
    • Camera

      public Camera(Projection p)
  • Method Details

    • getManageableType

      public ManageableType getManageableType()
      Specified by:
      getManageableType in interface Manageable
    • getProjection

      public Projection getProjection()
    • setProjection

      public void setProjection(Projection value)
    • getTransformation

      public Matrix4d getTransformation()
    • setTransformation

      public void setTransformation(Matrix4d value)
    • createPerspective

      public static Camera createPerspective()
    • createParallel

      public static Camera createParallel()
    • createTopView

      public static Camera createTopView()
    • createBottomView

      public static Camera createBottomView()
    • createLeftView

      public static Camera createLeftView()
    • createRightView

      public static Camera createRightView()
    • createFrontView

      public static Camera createFrontView()
    • createBackView

      public static Camera createBackView()
    • initProvider

      public void initProvider(SharedObjectProvider provider)
      Specified by:
      initProvider in interface Shareable
    • getProvider

      public SharedObjectProvider getProvider()
      Specified by:
      getProvider in interface Shareable
    • addReference

      public void addReference(SharedObjectReference ref)
      Specified by:
      addReference in interface Shareable
    • removeReference

      public void removeReference(SharedObjectReference ref)
      Specified by:
      removeReference in interface Shareable
    • appendReferencesTo

      public void appendReferencesTo(List out)
      Specified by:
      appendReferencesTo in interface Shareable
    • fieldModified

      public void fieldModified(PersistenceField field, int[] indices, Transaction t)
      Specified by:
      fieldModified in interface Manageable
    • 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
    • update

      public void update()
    • manageableReadResolve

      public Manageable manageableReadResolve()
      Specified by:
      manageableReadResolve in interface Manageable
    • manageableWriteReplace

      public Object manageableWriteReplace()
      Specified by:
      manageableWriteReplace in interface Manageable
    • getZNear

      public float getZNear()
      Specified by:
      getZNear in class CameraBase
    • getZFar

      public float getZFar()
      Specified by:
      getZFar in class CameraBase
    • setZNear

      public void setZNear(float minZ)
    • setZFar

      public void setZFar(float maxZ)
    • 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
    • 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
    • projectWorld

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

      public boolean projectView(float px, float py, float pz, Tuple2f point2D, boolean checkClip)
    • 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
    • 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
    • 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
    • generateRandomOrigins

      public void generateRandomOrigins(Environment env, RayList out, 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
    • getFlags

      public int getFlags()
      Specified by:
      getFlags in interface Scattering
    • 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).
    • generateRandomRays

      public void generateRandomRays(Environment env, Vector3f out, Spectrum specOut, RayList rays, boolean adjoint, 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:
    • 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, ν) specIni) 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) specIno) 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
    • completeRay

      public double completeRay(Environment env, Point3d vertex, Ray out)
      Specified by:
      completeRay in interface Emitter
    • getUVForVertex

      public float[] getUVForVertex(Environment env, Point3d vertex)
      Specified by:
      getUVForVertex in interface Sensor