ProSHADE: ProSHADE_internal_spheres::ProSHADE_rotFun_sphere Class Reference

| ProSHADE 0.7.5.4 (MAR 2021) Protein Shape Detection

Public Member Functions | List of all members
ProSHADE_internal_spheres::ProSHADE_rotFun_sphere Class Reference

This class contains all inputed data for the rotation function angle-axis converted spheres. More...

`#include <ProSHADE_maths.hpp>`

## Public Member Functions
| ProSHADE_rotFun_sphere (proshade_double rad, proshade_double radRange, proshade_unsign dim, proshade_double repAng, proshade_unsign sphNo)
| Constructor for getting empty ProSHADE_rotFun_sphere class. More...
| ~ProSHADE_rotFun_sphere (void)
| Destructor for releasing memory from the ProSHADE_rotFun_sphere class. More...
proshade_double | getRadius (void)
| Accessor function for the private variable radius. More...
proshade_double | getMaxRadius (void)
| Accessor function for the private variable maximum radius. More...
proshade_double | getMinRadius (void)
| Accessor function for the private variable minimal radius. More...
proshade_unsign | getAngularDim (void)
| Accessor function for the private variable angular dim. More...
proshade_double | getRepresentedAngle (void)
| Accessor function for the private variable represented angle. More...
proshade_unsign | getSphereNumber (void)
| Accessor function for the private variable sphere number. More...
std::vector< std::pair< proshade_unsign, proshade_unsign > > | getPeaks (void)
| Accessor function for the private variable containing all detected peaks. More...
proshade_double | getSphereLatLonPosition (proshade_unsign lattitude, proshade_unsign longitude)
| Accessor function for specific lattitude and longitude point of the sphere sampling grid. More...
proshade_double | getSphereLatLonLinearInterpolationPos (proshade_double lattitude, proshade_double longitude)
| Function for obtaining sphere values outside of the grid points. More...
void | interpolateSphereValues (proshade_complex *rotFun)
| Function for interpolating the sphere grid values from angle-axis converted rotation function. More...
void | findAllPeaks (proshade_signed noSmNeighbours, std::vector< proshade_double > *allHeights)
| Function for finding all peaks in the sampling grid. More...
void | removeSmallPeaks (proshade_double peakThres)
| Function for removing peaks with too small height. More...

## Detailed Description

This class contains all inputed data for the rotation function angle-axis converted spheres.

This class codes the object that contains all the information about a single concentric sphere in the angle-axis space obtained by conversion of the rotation function. It also contains all the functionality required to process such data.

Definition at line 50 of file ProSHADE_maths.hpp.

## Constructor & Destructor Documentation

## ◆ ProSHADE_rotFun_sphere()

ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::ProSHADE_rotFun_sphere | ( | proshade_double | rad,
|  | proshade_double | radRange,
|  | proshade_unsign | dim,
|  | proshade_double | repAng,
|  | proshade_unsign | sphNo
| ) |  |

Constructor for getting empty ProSHADE_rotFun_sphere class.

This function simply creates an object of the ProSHADE_rotFun_sphere class and allocates the memory as required.

Parameters

  [in] | rad | The radius of this sphere.
  [in] | radRange | The range in the radial dimension covered by this sphere.
  [in] | dim | The required size of the sampling grid.
  [in] | repAng | The angle represented by this sphere.
  [in] | sphNo | The number of this sphere in the spheres vector.
  [out] | X | Data object with all values set and ready to accept the rotation function values.

Definition at line 648 of file ProSHADE_spheres.cpp.

649 {
650 //================================================ Set internal values
651 this->radius = rad;
652 this->angularDim = dim;
653 this->radiusMin = this->radius - ( radRange / 2.0 );
654 this->radiusMax = this->radius + ( radRange / 2.0 );
655 this->representedAngle = repAng;
656 this->sphereNumber = sphNo;
657
658 //================================================ Allocate the axis field
659 this->axesValues = new proshade_double[dim*dim];
660 ProSHADE_internal_misc::checkMemoryAllocation ( this->axesValues, __FILE__, __LINE__, __func__ );
661
662 //================================================ Fill axis field with zeroes
663 for ( proshade_unsign iter = 0; iter < ( dim * dim ); iter++ ) { this->axesValues[iter] = 0.0; }
664
665 }

## ◆ ~ProSHADE_rotFun_sphere()

ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::~ProSHADE_rotFun_sphere | ( | void |  | ) |

Destructor for releasing memory from the ProSHADE_rotFun_sphere class.

Parameters

  [out] | X | N/A.

Definition at line 671 of file ProSHADE_spheres.cpp.

672 {
673 //================================================ Release the allocated memory
674 if ( this->axesValues != nullptr )
675 {
676 delete[] this->axesValues;
677 }
678 }

## Member Function Documentation

## ◆ findAllPeaks()

void ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::findAllPeaks | ( | proshade_signed | noSmNeighbours,
|  | std::vector< proshade_double > * | allHeights
| ) |  |

Function for finding all peaks in the sampling grid.

This function takes the values on the sampling grid and does a naive peak search, saving the peak position into an internal variable.

Parameters

  [in] | noSmNeighbours | The number of surrounding peaks in any direction that need to be smaller for a value to be a peak.
  [in] | allHeights | A vector to which all detected non-peaks heights will be saved into. This will later be used to determine the threshold for "small" peaks.

Definition at line 924 of file ProSHADE_spheres.cpp.

925 {
926 //================================================ Initialise local variables
927 proshade_double currentHeight;
928 proshade_signed nbLat, nbLon;
929 bool isPeak;
930
931 //================================================ Find all peaks
932 for ( proshade_signed latIt = 0; latIt < static_cast<proshade_signed> ( this->angularDim ); latIt++ )
933 {
934 for ( proshade_signed lonIt = 0; lonIt < static_cast<proshade_signed> ( this->angularDim ); lonIt++ )
935 {
936 //======================================== Initialise peak search
937 currentHeight = this->getSphereLatLonPosition ( latIt, lonIt );
938 isPeak = true;
939
940 //======================================== Find all neighbours in the same sphere
941 for ( proshade_signed latRound = -noSmNeighbours; latRound <= noSmNeighbours; latRound++ )
942 {
943 for ( proshade_signed lonRound = -noSmNeighbours; lonRound <= noSmNeighbours; lonRound++ )
944 {
945 //================================ Ignore same point
946 if ( latRound == 0 && lonRound == 0 ) { continue; }
947
948 //================================ Get neighbour height
949 nbLat = latIt + latRound;
950 nbLon = lonIt + lonRound;
951 if ( nbLat < 0 ) { nbLat += this->angularDim; } if ( nbLat >= static_cast<proshade_signed> ( this->angularDim ) ) { nbLat -= this->angularDim; }
952 if ( nbLon < 0 ) { nbLon += this->angularDim; } if ( nbLon >= static_cast<proshade_signed> ( this->angularDim ) ) { nbLon -= this->angularDim; }
953
954 //================================ If this value is larger than the tested one, no peak
955 if ( this->getSphereLatLonPosition ( nbLat, nbLon ) > currentHeight ) { isPeak = false; break; }
956 }
957
958 if ( !isPeak ) { break; }
959 }
960
961 if ( isPeak )
962 {
963 //==================================== Save!
964 this->peaks.emplace_back ( std::pair<proshade_unsign,proshade_unsign> ( latIt, lonIt ) );
965 }
966 else
967 {
968 ProSHADE_internal_misc::addToDoubleVector ( allHeights, currentHeight );
969 }
970 }
971 }
972
973 //================================================ Done
974 return ;
975
976 }

## ◆ getAngularDim()

proshade_unsign ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getAngularDim | ( | void |  | ) |

Accessor function for the private variable angular dim.

Parameters

  [out] | radius | The dimension size of the angular sampling grid.

Definition at line 705 of file ProSHADE_spheres.cpp.

706 {
707 //================================================ Done
708 return ( this->angularDim );
709
710 }

## ◆ getMaxRadius()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getMaxRadius | ( | void |  | ) |

Accessor function for the private variable maximum radius.

Parameters

  [out] | radius | The value of the maximum radius of this specific concentric shell.

Definition at line 694 of file ProSHADE_spheres.cpp.

695 {
696 //================================================ Done
697 return ( this->radiusMax );
698
699 }

## ◆ getMinRadius()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getMinRadius | ( | void |  | ) |

Accessor function for the private variable minimal radius.

Parameters

  [out] | radius | The value of the minimal radius of this specific concentric shell.

Definition at line 716 of file ProSHADE_spheres.cpp.

717 {
718 //================================================ Done
719 return ( this->radiusMin );
720
721 }

## ◆ getPeaks()

std::vector< std::pair< proshade_unsign, proshade_unsign > > ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getPeaks | ( | void |  | ) |

Accessor function for the private variable containing all detected peaks.

Parameters

  [out] | peaks | The vector containing all detected peaks.

Definition at line 749 of file ProSHADE_spheres.cpp.

750 {
751 //================================================ Done
752 return ( this->peaks );
753
754 }

## ◆ getRadius()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getRadius | ( | void |  | ) |

Accessor function for the private variable radius.

Parameters

  [out] | radius | The value of the radius of this specific concentric shell.

Definition at line 684 of file ProSHADE_spheres.cpp.

685 {
686 //================================================ Done
687 return ( this->radius );
688 }

## ◆ getRepresentedAngle()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getRepresentedAngle | ( | void |  | ) |

Accessor function for the private variable represented angle.

Parameters

  [out] | radius | The value of the angle represented by this sphere.

Definition at line 727 of file ProSHADE_spheres.cpp.

728 {
729 //================================================ Done
730 return ( this->representedAngle );
731
732 }

## ◆ getSphereLatLonLinearInterpolationPos()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getSphereLatLonLinearInterpolationPos | ( | proshade_double | lattitude,
|  | proshade_double | longitude
| ) |  |

Function for obtaining sphere values outside of the grid points.

This function computes linear interpolation value for any grid position of the sampling grid of this sphere.

Parameters

  [in] | lattitude | The lattitude index decimal place of the requested sampling grid position.
  [in] | longitude | The longitude index of the requested sampling grid position.
  [out] | radius | The value of the sampling grid position at given lattitude and longitude.

Definition at line 878 of file ProSHADE_spheres.cpp.

879 {
880 //================================================ Initialise variables
881 proshade_double c00, c01, c10, c11, c0, c1, latRelative, lonRelative;
882 proshade_signed latTop, latBottom, lonTop, lonBottom, gridIndex;
883
884 //================================================ Find lower and higher indices and deal with boundaries
885 latBottom = std::floor ( lattitude ); if ( latBottom < 0.0 ) { latBottom += this->angularDim; } if ( latBottom >= static_cast<proshade_signed> ( this->angularDim ) ) { latBottom -= this->angularDim; }
886 lonBottom = std::floor ( longitude ); if ( lonBottom < 0.0 ) { lonBottom += this->angularDim; } if ( lonBottom >= static_cast<proshade_signed> ( this->angularDim ) ) { lonBottom -= this->angularDim; }
887 latTop = std::ceil ( lattitude ); if ( latTop < 0.0 ) { latTop += this->angularDim; } if ( latTop >= static_cast<proshade_signed> ( this->angularDim ) ) { latTop -= this->angularDim; }
888 lonTop = std::ceil ( longitude ); if ( lonTop < 0.0 ) { lonTop += this->angularDim; } if ( lonTop >= static_cast<proshade_signed> ( this->angularDim ) ) { lonTop -= this->angularDim; }
889
890 //================================================ Interpolate
891 gridIndex = lonBottom + ( latBottom * static_cast<proshade_unsign> ( this->angularDim ) );
892 c00 = this->axesValues[gridIndex];
893
894 gridIndex = lonBottom + ( latTop * static_cast<proshade_unsign> ( this->angularDim ) );
895 c01 = this->axesValues[gridIndex];
896
897 gridIndex = lonTop + ( latBottom * static_cast<proshade_unsign> ( this->angularDim ) );
898 c10 = this->axesValues[gridIndex];
899
900 gridIndex = lonTop + ( latTop * static_cast<proshade_unsign> ( this->angularDim ) );
901 c11 = this->axesValues[gridIndex];
902
903 //================================================ Solve for longitude
904 lonRelative = longitude - std::floor( longitude );
905 c0 = ( c00 * ( 1.0 - lonRelative ) ) + ( c10 * lonRelative );
906 c1 = ( c01 * ( 1.0 - lonRelative ) ) + ( c11 * lonRelative );
907
908 //================================================ Solve for lattitude
909 latRelative = lattitude - std::floor ( lattitude );
910 proshade_double res = ( c0 * ( 1.0 - latRelative ) ) + ( c1 * latRelative );
911
912 //================================================ Done
913 return ( res );
914
915 }

## ◆ getSphereLatLonPosition()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getSphereLatLonPosition | ( | proshade_unsign | lattitude,
|  | proshade_unsign | longitude
| ) |  |

Accessor function for specific lattitude and longitude point of the sphere sampling grid.

Parameters

  [in] | lattitude | The lattitude index of the requested sampling grid point.
  [in] | longitude | The longitude index of the requested sampling grid point.
  [out] | radius | The value of the sampling grid point at given lattitude and longitude position.

Definition at line 864 of file ProSHADE_spheres.cpp.

865 {
866 //================================================ Done
867 return ( this->axesValues[longitude + ( lattitude * static_cast<proshade_unsign> ( this->angularDim ) )] );
868 }

## ◆ getSphereNumber()

proshade_unsign ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getSphereNumber | ( | void |  | ) |

Accessor function for the private variable sphere number.

Parameters

  [out] | sphereNumber | The sphere number.

Definition at line 738 of file ProSHADE_spheres.cpp.

739 {
740 //================================================ Done
741 return ( this->sphereNumber );
742
743 }

## ◆ interpolateSphereValues()

void ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::interpolateSphereValues | ( | proshade_complex * | rotFun | ) |

Function for interpolating the sphere grid values from angle-axis converted rotation function.

This function starts by converting each of the sphere sampling points lattitude and longitude to the XYZ position and by adding the represented rotation angle, obtains the angle-axis representation for the given point. It then proceeds to locate such points exact position in the indices space of the supplied rotation map. From there, it interpolates the exact correlation value for the given point, thus effectivelly re-sampling the rotation function space onto the sphere.

Parameters

  [in] | rotFun | proshade_complex pointer to the rotation function values.

Definition at line 765 of file ProSHADE_spheres.cpp.

766 {
767 //================================================ Initialise variables
768 proshade_double lonSampling = ( M_PI ) / static_cast<proshade_double> ( this->angularDim );
769 proshade_double latSampling = ( M_PI * 2.0 ) / static_cast<proshade_double> ( this->angularDim );
770
771 proshade_double lat, lon, cX, cY, cZ, c000, c001, c010, c011, c100, c101, c110, c111, c00, c01, c10, c11, c0, c1, xRelative, yRelative, zRelative, eulerAlpha, eulerBeta, eulerGamma, mapX, mapY, mapZ;
772 proshade_signed xBottom, xTop, yBottom, yTop, zBottom, zTop, mapIndex;
773
774 //================================================ For each sphere grid position
775 for ( proshade_signed lonIt = 0; lonIt < static_cast<proshade_signed> ( this->angularDim ); lonIt++ )
776 {
777 for ( proshade_signed latIt = 0; latIt < static_cast<proshade_signed> ( this->angularDim ); latIt++ )
778 {
779 //======================================== Convert to XYZ position on unit sphere. The radius here is not important, as it does not change the direction of the vector.
780 lon = static_cast<proshade_double> ( lonIt ) * lonSampling;
781 lat = static_cast<proshade_double> ( latIt ) * latSampling;
782 cX = 1.0 * std::sin ( lon ) * std::cos ( lat );
783 cY = 1.0 * std::sin ( lon ) * std::sin ( lat );
784 cZ = 1.0 * std::cos ( lon );
785
786 //======================================== Convert to ZXZ Euler angles
787 ProSHADE_internal_maths::getEulerZXZFromAngleAxis ( cX, cY, cZ, this->representedAngle, &eulerAlpha, &eulerBeta, &eulerGamma, this->angularDim );
788
789 //======================================== Convert to SOFT map position (decimal, not indices)
790 ProSHADE_internal_maths::getSOFTPositionFromEulerZXZ ( this->angularDim / 2, eulerAlpha, eulerBeta, eulerGamma, &mapX, &mapY, &mapZ );
791
792 //======================================== Find lower and higher points and deal with boundaries
793 xBottom = std::floor ( mapX ); if ( xBottom < 0.0 ) { xBottom += this->angularDim; } if ( xBottom >= static_cast<proshade_signed> ( this->angularDim ) ) { xBottom -= static_cast<proshade_signed> ( this->angularDim ); }
794 yBottom = std::floor ( mapY ); if ( yBottom < 0.0 ) { yBottom += this->angularDim; } if ( yBottom >= static_cast<proshade_signed> ( this->angularDim ) ) { yBottom -= static_cast<proshade_signed> ( this->angularDim ); }
795 zBottom = std::floor ( mapZ ); if ( zBottom < 0.0 ) { zBottom += this->angularDim; } if ( zBottom >= static_cast<proshade_signed> ( this->angularDim ) ) { zBottom -= static_cast<proshade_signed> ( this->angularDim ); }
796 xTop = std::ceil ( mapX ); if ( xTop < 0.0 ) { xTop += this->angularDim; } if ( xTop >= static_cast<proshade_signed> ( this->angularDim ) ) { xTop -= static_cast<proshade_signed> ( this->angularDim ); }
797 yTop = std::ceil ( mapY ); if ( yTop < 0.0 ) { yTop += this->angularDim; } if ( yTop >= static_cast<proshade_signed> ( this->angularDim ) ) { yTop -= static_cast<proshade_signed> ( this->angularDim ); }
798 zTop = std::ceil ( mapZ ); if ( zTop < 0.0 ) { zTop += this->angularDim; } if ( zTop >= static_cast<proshade_signed> ( this->angularDim ) ) { zTop -= static_cast<proshade_signed> ( this->angularDim ); }
799
800 //======================================== Start X interpolation - bottom, bottom, bottom
801 mapIndex = zBottom + this->angularDim * ( yBottom + this->angularDim * xBottom );
802 c000 = pow( rotFun[mapIndex][0], 2.0 ) + pow( rotFun[mapIndex][1], 2.0 );
803
804 //======================================== X interpolation - bottom, bottom, top
805 mapIndex = zTop + this->angularDim * ( yBottom + this->angularDim * xBottom );
806 c001 = pow( rotFun[mapIndex][0], 2.0 ) + pow( rotFun[mapIndex][1], 2.0 );
807
808 //======================================== X interpolation - bottom, top, bottom
809 mapIndex = zBottom + this->angularDim * ( yTop + this->angularDim * xBottom );
810 c010 = pow( rotFun[mapIndex][0], 2.0 ) + pow( rotFun[mapIndex][1], 2.0 );
811
812 //======================================== X interpolation - bottom, top, top
813 mapIndex = zTop + this->angularDim * ( yTop + this->angularDim * xBottom );
814 c011 = pow( rotFun[mapIndex][0], 2.0 ) + pow( rotFun[mapIndex][1], 2.0 );
815
816 //======================================== X interpolation - top, bottom, bottom
817 mapIndex = zBottom + this->angularDim * ( yBottom + this->angularDim * xTop );
818 c100 = pow( rotFun[mapIndex][0], 2.0 ) + pow( rotFun[mapIndex][1], 2.0 );
819
820 //======================================== X interpolation - top, bottom, top
821 mapIndex = zTop + this->angularDim * ( yBottom + this->angularDim * xTop );
822 c101 = pow( rotFun[mapIndex][0], 2.0 ) + pow( rotFun[mapIndex][1], 2.0 );
823
824 //======================================== X interpolation - top, top, bottom
825 mapIndex = zBottom + this->angularDim * ( yTop + this->angularDim * xTop );
826 c110 = pow( rotFun[mapIndex][0], 2.0 ) + pow( rotFun[mapIndex][1], 2.0 );
827
828 //======================================== X interpolation - top, top, top
829 mapIndex = zTop + this->angularDim * ( yTop + this->angularDim * xTop );
830 c111 = pow( rotFun[mapIndex][0], 2.0 ) + pow( rotFun[mapIndex][1], 2.0 );
831
832 //======================================== Solve for X
833 xRelative = mapX - std::floor( mapX );
834 c00 = ( c000 * ( 1.0 - xRelative ) ) + ( c100 * xRelative );
835 c01 = ( c001 * ( 1.0 - xRelative ) ) + ( c101 * xRelative );
836 c10 = ( c010 * ( 1.0 - xRelative ) ) + ( c110 * xRelative );
837 c11 = ( c011 * ( 1.0 - xRelative ) ) + ( c111 * xRelative );
838
839 //======================================== Solve for Y
840 yRelative = mapY - std::floor( mapY );
841 c0 = ( c00 * ( 1.0 - yRelative ) ) + ( c10 * yRelative );
842 c1 = ( c01 * ( 1.0 - yRelative ) ) + ( c11 * yRelative );
843
844 //======================================== Solve for Z
845 zRelative = mapZ - std::floor( mapZ );
846
847 //======================================== Save result
848 mapIndex = lonIt + ( latIt * static_cast<proshade_unsign> ( this->angularDim ) );
849 this->axesValues[mapIndex] = ( c0 * ( 1.0 - zRelative ) ) + ( c1 * zRelative );
850 }
851 }
852
853 //================================================ Done
854 return ;
855
856 }

## ◆ removeSmallPeaks()

void ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::removeSmallPeaks | ( | proshade_double | peakThres | ) |

Function for removing peaks with too small height.

This function takes the threshold for peaks being too small (computed from all peaks as returned by findAllPeaks() function, but could be any other value) and removes all peaks with height below this threshold.

Parameters

  [in] | peakThres | The height above which a peak needs to be in order not to be deleted.
  [in] | minThres | The minimum threshold that needs to be passed for a peak to be believed in.

Definition at line 986 of file ProSHADE_spheres.cpp.

987 {
988 //================================================ Initialise variables
989 proshade_double curHeight;
990 std::vector< proshade_unsign > dels ( 0, this->peaks.size() );
991
992 //================================================ For each peak in this sphere
993 for ( proshade_unsign peakIt = 0; peakIt < static_cast<proshade_unsign> ( this->peaks.size() ); peakIt++ )
994 {
995 //============================================ Find the peak height
996 curHeight = this->getSphereLatLonPosition ( this->peaks.at(peakIt).first, this->peaks.at(peakIt).second );
997
998 //============================================ Should this peak be deleted?
999 if ( curHeight < peakThres )
1000 {
1001 ProSHADE_internal_misc::addToUnsignVector ( &dels, peakIt );
1002 }
1003 }
1004
1005 //================================================ Descending sort to avoid changing the order
1006 std::sort ( dels.begin(), dels.end(), std::greater <proshade_unsign>() );
1007
1008 //================================================ Delete the low peaks
1009 for ( proshade_unsign delIt = 0; delIt < static_cast< proshade_unsign > ( dels.size() ); delIt++ )
1010 {
1011 this->peaks.erase ( this->peaks.begin() + dels.at(delIt) );
1012 }
1013
1014 //================================================ Done
1015 return ;
1016
1017 }

The documentation for this class was generated from the following files:

- src/proshade/ProSHADE_maths.hpp
- src/proshade/ProSHADE_spheres.cpp

ProSHADE_internal_maths::getSOFTPositionFromEulerZXZ
void getSOFTPositionFromEulerZXZ(proshade_signed band, proshade_double eulerAlpha, proshade_double eulerBeta, proshade_double eulerGamma, proshade_double *x, proshade_double *y, proshade_double *z)
Function to find the index position in the inverse SOFT map from given Euler angles (ZXZ convention).
Definition: ProSHADE_maths.cpp:986
ProSHADE_internal_maths::getEulerZXZFromAngleAxis
void getEulerZXZFromAngleAxis(proshade_double axX, proshade_double axY, proshade_double axZ, proshade_double axAng, proshade_double *eA, proshade_double *eB, proshade_double *eG, proshade_unsign angDim)
This function converts angle-axis representation to the Euler ZXZ angles representation.
Definition: ProSHADE_maths.cpp:1437
ProSHADE_internal_misc::addToDoubleVector
void addToDoubleVector(std::vector< proshade_double > *vecToAddTo, proshade_double elementToAdd)
Adds the element to the vector.
Definition: ProSHADE_misc.cpp:77
ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getSphereLatLonPosition
proshade_double getSphereLatLonPosition(proshade_unsign lattitude, proshade_unsign longitude)
Accessor function for specific lattitude and longitude point of the sphere sampling grid.
Definition: ProSHADE_spheres.cpp:864
ProSHADE_internal_misc::checkMemoryAllocation
void checkMemoryAllocation(chVar checkVar, std::string fileP, unsigned int lineP, std::string funcP, std::string infoP="This error may occurs when ProSHADE requests memory to be\n : allocated to it and this operation fails. This could\n : happen when not enough memory is available, either due to\n : other processes using a lot of memory, or when the machine\n : does not have sufficient memory available. Re-run to see\n : if this problem persists.")
Checks if memory was allocated properly.
Definition: ProSHADE_misc.hpp:65
ProSHADE_internal_misc::addToUnsignVector
void addToUnsignVector(std::vector< proshade_unsign > *vecToAddTo, proshade_unsign elementToAdd)
Adds the element to the vector.
Definition: ProSHADE_misc.cpp:99