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

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

Introduction

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

Prototype

public double getPhi() 

Source Link

Document

Get the polar (co-latitude) angle.

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;
        }/*  ww w . ja v a 2  s .  c  o m*/
        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.j av a2  s . c  om*/

    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.
 */// www .  java 2s  . 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();
}