Computes the homography based on a line and point on the plane
@param line Line on the plane
@param point Point on the plane
190869
public void process(PairLineNorm line, AssociatedPair point) {

		// t0 = (F*x) cross l'
		GeometryMath_F64.mult(F,point.p1,Fx);
		GeometryMath_F64.cross(Fx,line.getL2(),t0);
		// t1 = x' cross ((f*x) cross l')
		GeometryMath_F64.cross(point.p2, t0, t1);
		// t0 = x' cross e'
		GeometryMath_F64.cross(point.p2,e2,t0);

		double top = GeometryMath_F64.dot(t0,t1);
		double bottom = t0.normSq()*(line.l1.x*point.p1.x + line.l1.y*point.p1.y + line.l1.z);

		// e' * l^T
		GeometryMath_F64.outerProd(e2, line.l1, el);
		// cross(l')*F
		GeometryMath_F64.multCrossA(line.l2, F, lf);

		CommonOps_DDRM.add(lf,top/bottom,el,H);

		// pick a good scale and sign for H
		adjust.adjust(H, point);
	}
1119230
@NonNull
  private static List<Point> coordAll(@NonNull List<Point> coords, @NonNull Point point) {
    coords.add(point);
    return coords;
  }
562006
@NonNull
  private static List<Point> coordAll(@NonNull List<Point> coords, @NonNull LineString lineString) {
    coords.addAll(lineString.coordinates());
    return coords;
  }
632480
public static boolean isPointNearPoint(LatLng point, LatLng shapePoint, double tolerance) {
        return SphericalUtil.computeDistanceBetween(point, shapePoint) <= tolerance;
    }
100597
function(obj) {
                if (obj.normal) {
                  // obj is a plane
                  var V = this.line.intersectionWith(obj);
                  if (V === null) { return null; }
                  return this.pointClosestTo(V);
                } else {
                  // obj is a line (segment) or point
                  var P = this.line.pointClosestTo(obj);
                  if (P === null) { return null; }
                  if (this.contains(P)) { return P; }
                  return (this.line.positionOf(P) < 0 ? this.start : this.end).dup();
                }
              }
611473
function(point) {
        var result = false;

        if (point) {
            result =
                this.x === point.x &&
                this.y === point.y;
        }

        return result;
    }
250863
private static void getLinealGeometry(ArrayList<LineString> lines, Geometry geometry) {
         for (int i = 0; i < geometry.getNumGeometries(); i++) {
            Geometry subGeom = geometry.getGeometryN(i);
            if(subGeom instanceof LineString){
                lines.add((LineString) subGeom);
            }
            else if (subGeom instanceof GeometryCollection){
                getLinealGeometry(lines, subGeom);
            }
        }
    }
180495
@Pure
	public boolean containsProjectionOf(Point3f point) {
		return containsProjectionOf(point.getX(), point.getY(), point.getZ());
	}
546337
public void renderLines(float[] points, int count) {
		if (antialias) {
			GL.glEnable(SGL.GL_POLYGON_SMOOTH);
			renderLinesImpl(points,count,width+1f);
		}

		GL.glDisable(SGL.GL_POLYGON_SMOOTH);
		renderLinesImpl(points,count,width);
		
		if (antialias) {
			GL.glEnable(SGL.GL_POLYGON_SMOOTH);
		}
	}
1304654
public void transformPoint(final double[] point) {
		Point3d p = new Point3d(point[0],point[1],point[2]);
		transformation.transform(p);
		point[0] = p.x;
		point[1] = p.y;
		point[2] = p.z;
	}
269956
public void addPoint(Point p) {
		if (p == null) throw new NullPointerException();
		points.add(new Point(p));
		repaint();
	}
246134
public void setPoint( double x, double y ) {
        if (selection >= 0) {
            Coordinate coordinate = new Coordinate(x, y);
            pts.set(selection, coordinate);
        }
    }
309969
public static void apply(@NonNull ViewPosition pos, @NonNull Point point) {
        pos.view.set(point.x, point.y, point.x + 1, point.y + 1);
        pos.viewport.set(pos.view);
        pos.visible.set(pos.view);
        pos.image.set(pos.view);
    }
1122273
private void createLine( int index0 , int index1 , List<Point2D_I32> contour , LineGeneral2D_F64 line )
	{
		if( index1 < 0 )
			System.out.println("SHIT");
		Point2D_I32 p0 = contour.get(index0);
		Point2D_I32 p1 = contour.get(index1);

//		System.out.println("createLine "+p0+" "+p1);

		work.a.set(p0.x, p0.y);
		work.b.set(p1.x, p1.y);

		UtilLine2D_F64.convert(work,line);

		// ensure A*A + B*B = 1
		line.normalize();
	}
534383
public void setPoints(Iterable<Point> points) {
		if (points==null) throw new NullPointerException();
		this.points.clear();
		for (Point p : points) {
			this.points.add(new Point(p));
		}
		repaint();
	}
596346
function Point(point) {
        crs(point);
        bbox(point);
        geometrySemantics(point);
        if (!requiredProperty(point, 'coordinates', 'array')) {
            position(point.coordinates);
        }
    }
1337168
private void drawPoints(Canvas canvas, Line line, int lineIndex, int mode) {
        pointPaint.setColor(line.getPointColor());
        int valueIndex = 0;
        for (PointValue pointValue : line.getValues()) {
            int pointRadius = ChartUtils.dp2px(density, line.getPointRadius());
            final float rawX = computator.computeRawX(pointValue.getX());
            final float rawY = computator.computeRawY(pointValue.getY());
            if (computator.isWithinContentRect(rawX, rawY, checkPrecision)) {
                // Draw points only if they are within contentRectMinusAllMargins, using contentRectMinusAllMargins
                // instead of viewport to avoid some
                // float rounding problems.
                if (MODE_DRAW == mode) {
                    drawPoint(canvas, line, pointValue, rawX, rawY, pointRadius);
                    if (line.hasLabels()) {
                        drawLabel(canvas, line, pointValue, rawX, rawY, pointRadius + labelOffset);
                    }
                } else if (MODE_HIGHLIGHT == mode) {
                    highlightPoint(canvas, line, pointValue, rawX, rawY, lineIndex, valueIndex);
                } else {
                    throw new IllegalStateException("Cannot process points in mode: " + mode);
                }
            }
            ++valueIndex;
        }
    }