ProSHADE  0.7.6.0 (JUL 2021)
Protein Shape Detection
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 53 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]radThe radius of this sphere.
[in]radRangeThe range in the radial dimension covered by this sphere.
[in]dimThe required size of the sampling grid.
[in]repAngThe angle represented by this sphere.
[in]sphNoThe number of this sphere in the spheres vector.
[out]XData object with all values set and ready to accept the rotation function values.

Definition at line 645 of file ProSHADE_spheres.cpp.

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

◆ ~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]XN/A.

Definition at line 668 of file ProSHADE_spheres.cpp.

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

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]noSmNeighboursThe number of surrounding peaks in any direction that need to be smaller for a value to be a peak.
[in]allHeightsA 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 921 of file ProSHADE_spheres.cpp.

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

◆ getAngularDim()

proshade_unsign ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getAngularDim ( void  )

Accessor function for the private variable angular dim.

Parameters
[out]radiusThe dimension size of the angular sampling grid.

Definition at line 702 of file ProSHADE_spheres.cpp.

703 {
704  //================================================ Done
705  return ( this->angularDim );
706 
707 }

◆ getMaxRadius()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getMaxRadius ( void  )

Accessor function for the private variable maximum radius.

Parameters
[out]radiusThe value of the maximum radius of this specific concentric shell.

Definition at line 691 of file ProSHADE_spheres.cpp.

692 {
693  //================================================ Done
694  return ( this->radiusMax );
695 
696 }

◆ getMinRadius()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getMinRadius ( void  )

Accessor function for the private variable minimal radius.

Parameters
[out]radiusThe value of the minimal radius of this specific concentric shell.

Definition at line 713 of file ProSHADE_spheres.cpp.

714 {
715  //================================================ Done
716  return ( this->radiusMin );
717 
718 }

◆ 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]peaksThe vector containing all detected peaks.

Definition at line 746 of file ProSHADE_spheres.cpp.

747 {
748  //================================================ Done
749  return ( this->peaks );
750 
751 }

◆ getRadius()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getRadius ( void  )

Accessor function for the private variable radius.

Parameters
[out]radiusThe value of the radius of this specific concentric shell.

Definition at line 681 of file ProSHADE_spheres.cpp.

682 {
683  //================================================ Done
684  return ( this->radius );
685 }

◆ getRepresentedAngle()

proshade_double ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getRepresentedAngle ( void  )

Accessor function for the private variable represented angle.

Parameters
[out]radiusThe value of the angle represented by this sphere.

Definition at line 724 of file ProSHADE_spheres.cpp.

725 {
726  //================================================ Done
727  return ( this->representedAngle );
728 
729 }

◆ 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]lattitudeThe lattitude index decimal place of the requested sampling grid position.
[in]longitudeThe longitude index of the requested sampling grid position.
[out]radiusThe value of the sampling grid position at given lattitude and longitude.

Definition at line 875 of file ProSHADE_spheres.cpp.

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

◆ 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]lattitudeThe lattitude index of the requested sampling grid point.
[in]longitudeThe longitude index of the requested sampling grid point.
[out]radiusThe value of the sampling grid point at given lattitude and longitude position.

Definition at line 861 of file ProSHADE_spheres.cpp.

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

◆ getSphereNumber()

proshade_unsign ProSHADE_internal_spheres::ProSHADE_rotFun_sphere::getSphereNumber ( void  )

Accessor function for the private variable sphere number.

Parameters
[out]sphereNumberThe sphere number.

Definition at line 735 of file ProSHADE_spheres.cpp.

736 {
737  //================================================ Done
738  return ( this->sphereNumber );
739 
740 }

◆ 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]rotFunproshade_complex pointer to the rotation function values.

Definition at line 762 of file ProSHADE_spheres.cpp.

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

◆ 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]peakThresThe height above which a peak needs to be in order not to be deleted.
[in]minThresThe minimum threshold that needs to be passed for a peak to be believed in.

Definition at line 983 of file ProSHADE_spheres.cpp.

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

The documentation for this class was generated from the following files:
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:988
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)
This function converts angle-axis representation to the Euler ZXZ angles representation.
Definition: ProSHADE_maths.cpp:1602
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:861
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:67
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