ProSHADE  0.7.5.4 (MAR 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 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]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 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]XN/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]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 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]radiusThe 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]radiusThe 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]radiusThe 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]peaksThe 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]radiusThe 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]radiusThe 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]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 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]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 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]sphereNumberThe 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]rotFunproshade_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]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 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  {
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:
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