GLine2D

java.lang.Object
- edu.umich.eecs.april.jmat.geom.GLine2D

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable
```
public class GLine2D
extends java.lang.Object
implements java.lang.Cloneable, java.io.Serializable
```
A 2D line

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class GLine2D.Fitter

Nested Classes
Modifier and Type	Class and Description
`static class`	`GLine2D.Fitter`

Field Summary

Fields
Modifier and Type	Field and Description
`protected double`	`dx` A vector representing the slope of the line
`protected double`	`dy` A vector representing the slope of the line
`(package private) boolean`	`normalizedp`
`(package private) boolean`	`normalizedSlope`
`(package private) double[]`	`p` A point that the line passes through.
`(package private) static long`	`serialVersionUID`
`protected static GLine2D`	`XAXIS`
`protected static GLine2D`	`YAXIS`

Constructor Summary

Constructors
Constructor and Description
`GLine2D()`
`GLine2D(double[] p1, double[] p2)` Create a new line through two points.
`GLine2D(double M, double b)` Create a new line
`GLine2D(double dx, double dy, double[] p)` Create a new line

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`distanceTo(double[] p)`
`static GLine2D`	`fromRmatrix(Matrix R)` Create a line from the vector from the origin to the line that is perpendicular to the line.
`static GLine2D`	`fromRTheta(double r, double theta)` Create a new line given a distance and angle from the origin that is perpendicular to the line.
`static GLine2D`	`fromThetaPoint(double theta, double[] p)` Create a line that is at angle theta from the x axis and passes through point p
`double`	`getB()` Get the y intercept of the line
`double`	`getDistX(double[] p0)` Is point p to the left of the line?
`double`	`getDistY(double[] p0)` What is the vertical distance between p and the line?
`double`	`getDx()` Get component of unit vector
`double`	`getDy()` Get component of unit vector
`double`	`getLineCoordinate(double[] p)` Get the coordinate of a point (on this line), with 0 corresponding to the point on the line that is perpendicular to a line passing through the origin and the line.
`double`	`getM()` Get the slope of the line
`double[]`	`getPoint()` Get an arbitrary point on the line.
`double[]`	`getPointOfCoordinate(double coord)` The inverse of getLineCoordinate.
`Matrix`	`getR()` The 2x1 vector from the origin to the line that is perpendicular to the line.
`double`	`getTheta()` Get the angle of the line (the angle between the line and the X axis.)
`Matrix`	`getU()` The 2x1 unit vector corresponding to the slope of the line.
`double[]`	`intersectionWith(GLine2D l)` Compute the point where two lines intersect, or null if the lines are parallel.
`static GLine2D`	`lsqFit(java.util.List<double[]> points)`
`static GLine2D`	`lsqFit(java.util.List<double[]> points, double[] weights)`
`static GLine2D`	`lsqFitXYW(java.util.List<double[]> xyweight)`
`static void`	`main(java.lang.String[] args)` Self tests
`protected void`	`normalizeP()`
`protected void`	`normalizeSlope()`
`void`	`optimize()` Hint that the object should be optimized for future computation by putting the internal representation into a more convenient format.
`GLine2D`	`parallelLineThrough(double[] pin)` Return a line parallel to this line that passes through the specified point.
`double`	`perpendicularDistanceTo(double[] pin)` Compute the perpendicular distance between a point and the line
`GLine2D`	`perpendicularLine()` A line perpendicular to this line.
`GLine2D`	`perpendicularLineThrough(double[] pin)` The line perpendicular to this line that passes through point p
`double[]`	`pointOnLineClosestTo(double[] pin)`
`(package private) static double`	`square(double x)`
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - YAXIS
```
protected static GLine2D YAXIS
```
  - XAXIS
```
protected static GLine2D XAXIS
```
  - serialVersionUID
```
static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
  - dx
```
protected double dx
```
    A vector representing the slope of the line
  - dy
```
protected double dy
```
    A vector representing the slope of the line
  - p
```
double[] p
```
    A point that the line passes through. When normalized, it is the point on the line closest to the origin.
  - normalizedSlope
```
boolean normalizedSlope
```
  - normalizedp
```
boolean normalizedp
```
- Constructor Detail
  - GLine2D
```
public GLine2D()
```
  - GLine2D
```
public GLine2D(double dx,
               double dy,
               double[] p)
```
    Create a new line
    
    Parameters:
    
    dx - A change in X corresponding to dy
    
    dy - A change in Y corresponding to dx
    
    p - A point that the line passes through
  - GLine2D
```
public GLine2D(double M,
               double b)
```
    Create a new line
    
    Parameters:
    
    M - the slope
    
    b - the y intercept
  - GLine2D
```
public GLine2D(double[] p1,
               double[] p2)
```
    Create a new line through two points.
- Method Detail
  - optimize
```
public void optimize()
```
    Hint that the object should be optimized for future computation by putting the internal representation into a more convenient format. This never affects correctness, only performance.
  - normalizeSlope
```
protected void normalizeSlope()
```
  - getM
```
public double getM()
```
    Get the slope of the line
  - getB
```
public double getB()
```
    Get the y intercept of the line
  - getLineCoordinate
```
public double getLineCoordinate(double[] p)
```
    Get the coordinate of a point (on this line), with 0 corresponding to the point on the line that is perpendicular to a line passing through the origin and the line. This allows easy computation if one point is between two other points on the line: compute the line coordinate of all three points and test if a<=b<=c. This is implemented by computing the dot product of the vector p with the line's direction unit vector.
  - getPointOfCoordinate
```
public double[] getPointOfCoordinate(double coord)
```
    The inverse of getLineCoordinate.
  - fromRmatrix
```
public static GLine2D fromRmatrix(Matrix R)
```
    Create a line from the vector from the origin to the line that is perpendicular to the line.
    
    Parameters:
    
    R - a 2x1 matrix [x y]'
  - fromRTheta
```
public static GLine2D fromRTheta(double r,
                                 double theta)
```
    Create a new line given a distance and angle from the origin that is perpendicular to the line.
  - fromThetaPoint
```
public static GLine2D fromThetaPoint(double theta,
                                     double[] p)
```
    Create a line that is at angle theta from the x axis and passes through point p
  - perpendicularLine
```
public GLine2D perpendicularLine()
```
    A line perpendicular to this line.
  - normalizeP
```
protected void normalizeP()
```
  - getR
```
public Matrix getR()
```
    The 2x1 vector from the origin to the line that is perpendicular to the line.
  - getU
```
public Matrix getU()
```
    The 2x1 unit vector corresponding to the slope of the line.
  - getTheta
```
public double getTheta()
```
    Get the angle of the line (the angle between the line and the X axis.) Note that a line has two possible values, T and T+180.
  - perpendicularLineThrough
```
public GLine2D perpendicularLineThrough(double[] pin)
```
    The line perpendicular to this line that passes through point p
  - parallelLineThrough
```
public GLine2D parallelLineThrough(double[] pin)
```
    Return a line parallel to this line that passes through the specified point.
  - intersectionWith
```
public double[] intersectionWith(GLine2D l)
```
    Compute the point where two lines intersect, or null if the lines are parallel.
  - pointOnLineClosestTo
```
public double[] pointOnLineClosestTo(double[] pin)
```
  - perpendicularDistanceTo
```
public double perpendicularDistanceTo(double[] pin)
```
    Compute the perpendicular distance between a point and the line
  - distanceTo
```
public double distanceTo(double[] p)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getDistY
```
public double getDistY(double[] p0)
```
    What is the vertical distance between p and the line?
  - getDistX
```
public double getDistX(double[] p0)
```
    Is point p to the left of the line?
  - getDx
```
public double getDx()
```
    Get component of unit vector
  - getDy
```
public double getDy()
```
    Get component of unit vector
  - getPoint
```
public double[] getPoint()
```
    Get an arbitrary point on the line.
  - main
```
public static void main(java.lang.String[] args)
```
    Self tests
  - square
```
static final double square(double x)
```
  - lsqFit
```
public static GLine2D lsqFit(java.util.List<double[]> points)
```
  - lsqFit
```
public static GLine2D lsqFit(java.util.List<double[]> points,
                             double[] weights)
```
  - lsqFitXYW
```
public static GLine2D lsqFitXYW(java.util.List<double[]> xyweight)
```

Class GLine2D

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

YAXIS

XAXIS

serialVersionUID

dx

dy

p

normalizedSlope

normalizedp

Constructor Detail

GLine2D

GLine2D

GLine2D

GLine2D

Method Detail

optimize

normalizeSlope

getM

getB

getLineCoordinate

getPointOfCoordinate

fromRmatrix

fromRTheta

fromThetaPoint

perpendicularLine

normalizeP

getR

getU

getTheta

perpendicularLineThrough

parallelLineThrough

intersectionWith

pointOnLineClosestTo

perpendicularDistanceTo

distanceTo

toString

getDistY

getDistX

getDx

getDy

getPoint

main

square

lsqFit

lsqFit

lsqFitXYW