All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class rsf.operator.Projection

java.lang.Object
   |
   +----sep.operator.SepLinearOperator
           |
           +----rsf.operator.Projection

public class Projection

extends SepLinearOperator

steps

weights

Projection(Projection)

Projection(RsfSpace)

Projection(RsfSpace, RsfSpace)

apply(boolean, Vector, Vector)

Apply the operator:

Depending on if the operator is the forward or adjoint:
forward: out = A(in)
adjoint: in = A(out)

CONTRAST THIS INTERFACE WITH THAT OF SepSelfAdjointOperator.apply()

copy()

createRange(RsfSpace)

This defaults the delta and offset of projection space.

equals(Object)

Compares two Objects for equality.

setNormal(double)

This specifies the direction of the projection of planes.

setNormal(double, double)

This specifies the direction of the projection of volumes.

setNormal(double[])

alpha.length = 1 Projects a plane.

setStepout(float[])

steps lists the components of the normal vector n in f(nx).

setWeights()

Normalizes the forward and adjoint operation so that adjoint(forward(const)) = const.

toString()

Returns a string representation of the object.

 protected float steps[]

 protected Rsf weights

 public Projection(RsfSpace domain,
                   RsfSpace range)

Parameters:

domain: - 2-D space of the projected data.

range: - 1-D space into which the domain is projected.

steps: - The vector n=(n_x,n_y, ..) in f(nx) (points in the gradient direction).

 public Projection(RsfSpace domain)

 protected Projection(Projection src)

 public static RsfSpace createRange(RsfSpace domain)

This defaults the delta and offset of projection space.

 public void setNormal(double alpha[])

alpha.length = 1 Projects a plane. Invokes setNormal(alpha[0]). alpha.length = 2 Projects a volume. Invokes setNormal(alpha[0],alpha[1]).

 public void setNormal(double alpha)

This specifies the direction of the projection of planes. alpha is the angle with the z-Axis (as usual in geophysics). (I probably should change this: angle with the x-Axis). This parameterisation is standard for polar coordinates.
n = [sin(a), cos(a)]
Alpha is in mulitples of Math.PI. The units of n are pixels.

 public void setNormal(double alpha,
                       double gamma)

This specifies the direction of the projection of volumes. This can be done several ways. I choose to define the normal vector by its two spherical angles. The normal vector n relates to the one-dimensional source function f() by f(n x). I specify the normal vector n with two angles.

Parameters:

gamma - (short g) angle of n with the z axis.

alpha - (short a) angle of n's projection into the xy plane with the x axis. This parameterisation is standard for spherical coordinates.
n = [sin(g) cos(a), sin(g) sin(a), cos(g)]
The units are pixels.

Alternatively, I was considering a definition by dip and strike angle: The strike angle s is the angle between the constant plane and the x-axis in the x-y plane. The dip angle is the angle between the constant plane and the z-axis. In terms of the gamma and alpha of the spherical coordinates (normal description), the dip and strike vectors are: strike = [sin(a), -cos(a), 0] dip = [-cos(g) cos(a), -cos(g) sin(a), sin(g)]

 public void setStepout(float steps[])

steps lists the components of the normal vector n in f(nx).

Parameters:

steps - = {n_x, n_y, n_z} (or {n_x, n_y} for 2-D). I spread f(x) into the volume by looping over location y[ix][iy][iz] and computing f(y * n) where * is the dot product between the location vector and the here specified normal vector n. The input array steps is normalized before using it.

 public void apply(boolean add,
                   Vector vol,
                   Vector lne)

Apply the operator:

Depending on if the operator is the forward or adjoint:
forward: out = A(in)
adjoint: in = A(out)

CONTRAST THIS INTERFACE WITH THAT OF SepSelfAdjointOperator.apply()

Overrides:

apply in class SepLinearOperator

 public void setWeights()

Normalizes the forward and adjoint operation so that adjoint(forward(const)) = const. The scaling is Sqrt(1 / Number_of_contributions_to_Line_Pixel).
HACK!! Reimplements part of the actual operator. I could compute the analytic solution of the integral

 public boolean equals(Object p2)

Compares two Objects for equality.

Overrides:

equals in class Object

 public JamObject copy()

Overrides:

copy in class SepLinearOperator

 public String toString()

Returns a string representation of the object.

Overrides:

toString in class Object

All Packages  Class Hierarchy  This Package  Previous  Next  Index