Example usage for org.apache.commons.math3.geometry.euclidean.threed SphericalCoordinates getTheta

List of usage examples for org.apache.commons.math3.geometry.euclidean.threed SphericalCoordinates getTheta

Introduction

In this page you can find the example usage for org.apache.commons.math3.geometry.euclidean.threed SphericalCoordinates getTheta.

Prototype

public double getTheta() 

Source Link

Document

Get the azimuthal angle in x-y plane.

Usage

From source file:fingerprint.MyStructureFingerprint.java

private PhiThetaInterval getIntervalFromSphericalCoordinates(SphericalCoordinates pointShericalRelative,
        List<PhiThetaInterval> sectors) {

    double phi = pointShericalRelative.getPhi();
    double theta = pointShericalRelative.getTheta();

    for (PhiThetaInterval phiThetaInterval : sectors) {
        double phiMin = phiThetaInterval.getPhiMin();
        double phiMax = phiThetaInterval.getPhiMax();
        double thetaMin = phiThetaInterval.getThetaMin();
        double thetaMax = phiThetaInterval.getThetaMax();

        if (phi < phiMin || phi > phiMax) {
            continue;
        }/*from   w  w w . j a  v a  2s  . com*/
        if (theta < thetaMin || theta > thetaMax) {
            continue;
        }

        return phiThetaInterval;

    }
    // sector was not found
    return null;
}

From source file:fr.amap.lidar.format.jleica.LPointShotExtractor.java

public LPointShotExtractor(GriddedPointScan scan) throws Exception {

    this.scan = scan;

    scan.computeExtremumsAngles();/*from   w w w .jav a2  s  .  co m*/

    scan.openScanFile(scan.getFile());

    angles = new SimpleSpherCoords[this.scan.getHeader().getNumRows()][this.scan.getHeader().getNumCols()];

    azimuts = new boolean[this.scan.getHeader().getNumCols()];
    zenithals = new boolean[this.scan.getHeader().getNumRows()];

    //azimutsRegression  = new SimpleRegression[this.scan.getHeader().getNumCols()];
    //zenithalsRegression = new SimpleRegression[this.scan.getHeader().getNumRows()];

    //azimuts = new SimpleRegression[this.scan.getHeader().getNumCols()];
    //zenithals = new SimpleRegression[this.scan.getHeader().getNumRows()];

    Iterator<LPoint> iterator = scan.iterator();

    while (iterator.hasNext()) {

        LPoint point = iterator.next();

        if (point.valid) {

            double x, y, z;

            if (scan.getHeader().isPointInDoubleFormat()) {
                x = ((LDoublePoint) point).x;
                y = ((LDoublePoint) point).y;
                z = ((LDoublePoint) point).z;
            } else {
                x = ((LFloatPoint) point).x;
                y = ((LFloatPoint) point).y;
                z = ((LFloatPoint) point).z;
            }

            Vector3d dir = new Vector3d(x, y, z);
            dir.normalize();

            SphericalCoordinates sc = new SphericalCoordinates(new Vector3D(dir.x, dir.y, dir.z));

            angles[point.rowIndex][point.columnIndex] = new SimpleSpherCoords();
            angles[point.rowIndex][point.columnIndex].azimut = sc.getTheta();
            angles[point.rowIndex][point.columnIndex].zenith = sc.getPhi();

            azimuts[point.columnIndex] = true;
            zenithals[point.rowIndex] = true;
        }
    }

    int lastValidRowIndex = -1;
    int lastValidColumnIndex = -1;

    for (int row = 0; row < angles.length; row++) {

        for (int column = 0; column < angles[0].length; column++) {

            if (angles[row][column] == null) {

                double azimut = Double.NaN;
                double zenithal = Double.NaN;

                if (azimuts[column]) {
                    for (int i = row + 1, j = row - 1; i < angles.length || j >= 0; i++, j--) {

                        if (i < angles.length && angles[i][column] != null) {
                            azimut = angles[i][column].azimut;
                            azimuts[column] = true;
                            break;
                        }

                        if (j >= 0 && angles[j][column] != null) {
                            azimut = angles[j][column].azimut;
                            azimuts[column] = true;
                            break;
                        }
                    }
                }

                if (azimuts[column]) {

                    for (int i = row + 1, j = row - 1; i < angles.length || j >= 0; i++, j--) {

                        if (i < angles.length && angles[i][column] != null) {
                            zenithal = (angles[i][column].zenith + ((i - row) * scan.getElevationStepAngle()));
                            azimuts[column] = true;
                            break;
                        }

                        if (j >= 0 && angles[j][column] != null) {
                            zenithal = (angles[j][column].zenith - ((row - j) * scan.getElevationStepAngle()));
                            azimuts[column] = true;
                            break;
                        }
                    }
                }

                /*if(zenithals[row]){
                        
                for(int i=column+1, j=column-1;i<angles[0].length || j>=0;i++, j--){
                        
                    if(i<angles[0].length && angles[row][i] != null){
                        zenithal = angles[row][i].zenith;
                        zenithals[row] = true;
                        break;
                    }
                        
                    if(j >=0 && angles[row][j] != null){
                        zenithal = angles[row][j].zenith;
                        zenithals[row] = true;
                        break;
                    }
                }
                }*/

                if (Double.isNaN(azimut)) {
                    azimut = (scan.getAzim_min()
                            - ((column - scan.getColIndexAzimMin()) * scan.getAzimutalStepAngle()));
                }

                if (Double.isNaN(zenithal)) {
                    if (lastValidRowIndex != -1) {
                        zenithal = (angles[lastValidRowIndex][lastValidColumnIndex].zenith
                                - ((row - lastValidRowIndex) * scan.getElevationStepAngle()));
                    } else {
                        zenithal = (scan.getElev_min()
                                - ((row - scan.getRowIndexElevMin()) * scan.getElevationStepAngle()));
                    }

                }

                angles[row][column] = new SimpleSpherCoords(azimut, zenithal);

            } else {
                lastValidRowIndex = row;
                lastValidColumnIndex = column;
            }
        }
    }

}

From source file:fr.amap.lidar.format.jleica.GriddedPointScan.java

/**
 * Compute minimum and maximum azimutal and elevation angles of the scan.
 *//*from  ww w.j  a v a 2  s  . co m*/
public void computeExtremumsAngles() {

    Statistic minAzimutalAngle = new Statistic();
    Statistic maxAzimutalAngle = new Statistic();

    resetRowLimits();
    resetColumnLimits();

    //compute min azimutal angle
    int i;

    for (i = 0; i < header.getNumCols(); i++) {

        setUpColumnToRead(i);

        Iterator<LPoint> iterator = this.iterator();

        while (iterator.hasNext()) {

            LPoint point = iterator.next();

            SphericalCoordinates sc;

            if (header.isPointInFloatFormat()) {

                LFloatPoint floatPoint = (LFloatPoint) point;
                sc = new SphericalCoordinates(
                        new Vector3D(floatPoint.x, floatPoint.y, floatPoint.z).normalize());
            } else {
                LDoublePoint doublePoint = (LDoublePoint) point;
                sc = new SphericalCoordinates(
                        new Vector3D(doublePoint.x, doublePoint.y, doublePoint.z).normalize());
            }

            minAzimutalAngle.addValue(sc.getTheta());
        }

        if (minAzimutalAngle.getNbValues() > 0) {
            break;
        }
    }

    azim_min = minAzimutalAngle.getMean();
    colIndexAzimMin = i;

    //compute max azimutal angle
    //        for (i = colIndexAzimMin+100; i < header.getNumCols(); i+=100) {
    //            
    //            setUpColumnToRead(i);
    //            
    //            Iterator<LPoint> iterator = this.iterator();
    //
    //            while(iterator.hasNext()){
    //
    //                LPoint point = iterator.next();
    //
    //                SphericalCoordinates sc = new SphericalCoordinates();
    //
    //                if(header.isPointInFloatFormat()){
    //
    //                    LFloatPoint floatPoint = (LFloatPoint)point;
    //                    sc.toSpherical(new Point3d(floatPoint.x, floatPoint.y, floatPoint.z));
    //                }else{
    //                    LDoublePoint doublePoint = (LDoublePoint)point;
    //                    sc.toSpherical(new Point3d(doublePoint.x, doublePoint.y, doublePoint.z));
    //                }
    //
    //                maxAzimutalAngle.addValue(sc.getAzimuth());
    //            }
    //            
    //            if(maxAzimutalAngle.getNbValues() > 0){
    //                break;
    //            }
    //        }
    //        
    //        azim_max = maxAzimutalAngle.getMean();
    //        colIndexAzimMax = i;
    for (i = header.getNumCols() - 1; i >= 0; i--) {

        setUpColumnToRead(i);

        Iterator<LPoint> iterator = this.iterator();

        while (iterator.hasNext()) {

            LPoint point = iterator.next();

            SphericalCoordinates sc;

            if (header.isPointInFloatFormat()) {

                LFloatPoint floatPoint = (LFloatPoint) point;
                sc = new SphericalCoordinates(
                        new Vector3D(floatPoint.x, floatPoint.y, floatPoint.z).normalize());
            } else {
                LDoublePoint doublePoint = (LDoublePoint) point;
                sc = new SphericalCoordinates(
                        new Vector3D(doublePoint.x, doublePoint.y, doublePoint.z).normalize());
            }

            maxAzimutalAngle.addValue(sc.getTheta());
        }

        if (maxAzimutalAngle.getNbValues() > 0) {
            break;
        }
    }

    azim_max = maxAzimutalAngle.getMean();
    colIndexAzimMax = i;

    //compute min zenithal angle
    //compute max azimutal angle

    resetColumnLimits();

    Statistic minZenithalAngle = new Statistic();
    Statistic maxZenithalAngle = new Statistic();

    for (i = 0; i < header.getNumRows(); i++) {

        setUpRowToRead(i);

        Iterator<LPoint> iterator = this.iterator();

        while (iterator.hasNext()) {

            LPoint point = iterator.next();

            SphericalCoordinates sc;

            if (header.isPointInFloatFormat()) {

                LFloatPoint floatPoint = (LFloatPoint) point;
                sc = new SphericalCoordinates(
                        new Vector3D(floatPoint.x, floatPoint.y, floatPoint.z).normalize());
            } else {
                LDoublePoint doublePoint = (LDoublePoint) point;
                sc = new SphericalCoordinates(
                        new Vector3D(doublePoint.x, doublePoint.y, doublePoint.z).normalize());
            }

            minZenithalAngle.addValue(sc.getPhi());
        }

        if (minZenithalAngle.getNbValues() > 0) {
            break;
        }
    }

    elev_min = minZenithalAngle.getMean();
    rowIndexElevMin = i;

    for (i = header.getNumRows() - 1; i >= 0; i--) {

        setUpRowToRead(i);

        Iterator<LPoint> iterator = this.iterator();

        while (iterator.hasNext()) {

            LPoint point = iterator.next();

            SphericalCoordinates sc;

            if (header.isPointInFloatFormat()) {

                LFloatPoint floatPoint = (LFloatPoint) point;
                sc = new SphericalCoordinates(
                        new Vector3D(floatPoint.x, floatPoint.y, floatPoint.z).normalize());
            } else {
                LDoublePoint doublePoint = (LDoublePoint) point;
                sc = new SphericalCoordinates(
                        new Vector3D(doublePoint.x, doublePoint.y, doublePoint.z).normalize());
            }

            maxZenithalAngle.addValue(sc.getPhi());
        }

        if (maxZenithalAngle.getNbValues() > 0) {
            break;
        }

    }

    elev_max = maxZenithalAngle.getMean();
    rowIndexElevMax = i;

    resetRowLimits();
    resetColumnLimits();
}