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
Projection of two or three dimensional data to a 1-D line. (I may need at some point a projection of a three dimensional data to 2-D.)


Variable Index

 o steps
 o weights

Constructor Index

 o Projection(Projection)
 o Projection(RsfSpace)
 o Projection(RsfSpace, RsfSpace)

Method Index

 o 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()
 o copy()
 o createRange(RsfSpace)
This defaults the delta and offset of projection space.
 o equals(Object)
Compares two Objects for equality.
 o setNormal(double)
This specifies the direction of the projection of planes.
 o setNormal(double, double)
This specifies the direction of the projection of volumes.
 o setNormal(double[])
alpha.length = 1 Projects a plane.
 o setStepout(float[])
steps lists the components of the normal vector n in f(nx).
 o setWeights()
Normalizes the forward and adjoint operation so that adjoint(forward(const)) = const.
 o toString()
Returns a string representation of the object.

Variables

 o steps
 protected float steps[]
 o weights
 protected Rsf weights

Constructors

 o Projection
 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).
 o Projection
 public Projection(RsfSpace domain)
 o Projection
 protected Projection(Projection src)

Methods

 o createRange
 public static RsfSpace createRange(RsfSpace domain)
This defaults the delta and offset of projection space.

 o setNormal
 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]).

 o setNormal
 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.

 o setNormal
 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)]

 o setStepout
 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.
 o apply
 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
 o setWeights
 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

 o equals
 public boolean equals(Object p2)
Compares two Objects for equality.

Overrides:
equals in class Object
 o copy
 public JamObject copy()
Overrides:
copy in class SepLinearOperator
 o toString
 public String toString()
Returns a string representation of the object.

Overrides:
toString in class Object

All Packages  Class Hierarchy  This Package  Previous  Next  Index