diff --git a/assignment-client/src/entities/EntityTreeSendThread.cpp b/assignment-client/src/entities/EntityTreeSendThread.cpp
index 1d506ba47c..e04dc5553e 100644
--- a/assignment-client/src/entities/EntityTreeSendThread.cpp
+++ b/assignment-client/src/entities/EntityTreeSendThread.cpp
@@ -120,8 +120,8 @@ void EntityTreeSendThread::traverseTreeAndSendContents(SharedNodePointer node, O
                                 float priority = _conicalView.computePriority(cube);
                                 if (priority != PrioritizedEntity::DO_NOT_SEND) {
                                     float distance = glm::distance(cube.calcCenter(), viewPosition) + MIN_VISIBLE_DISTANCE;
-                                    float apparentAngle = cube.getScale() / distance;
-                                    if (apparentAngle > MIN_ENTITY_APPARENT_ANGLE * lodScaleFactor) {
+                                    float angularDiameter = cube.getScale() / distance;
+                                    if (angularDiameter > MIN_ENTITY_ANGULAR_DIAMETER * lodScaleFactor) {
                                         _sendQueue.push(PrioritizedEntity(entity, priority));
                                         _entitiesInQueue.insert(entity.get());
                                     }
@@ -241,8 +241,8 @@ void EntityTreeSendThread::startNewTraversal(const ViewFrustum& view, EntityTree
                             // pops to the next higher cell. So we want to check to see that the entity is large enough to be seen
                             // before we consider including it.
                             float distance = glm::distance(cube.calcCenter(), viewPosition) + MIN_VISIBLE_DISTANCE;
-                            float apparentAngle = cube.getScale() / distance;
-                            if (apparentAngle > MIN_ENTITY_APPARENT_ANGLE * lodScaleFactor) {
+                            float angularDiameter = cube.getScale() / distance;
+                            if (angularDiameter > MIN_ENTITY_ANGULAR_DIAMETER * lodScaleFactor) {
                                 float priority = _conicalView.computePriority(cube);
                                 _sendQueue.push(PrioritizedEntity(entity, priority));
                                 _entitiesInQueue.insert(entity.get());
@@ -287,8 +287,8 @@ void EntityTreeSendThread::startNewTraversal(const ViewFrustum& view, EntityTree
                                 if (next.intersection == ViewFrustum::INSIDE || _traversal.getCurrentView().cubeIntersectsKeyhole(cube)) {
                                     // See the DiffTraversal::First case for an explanation of the "entity is too small" check
                                     float distance = glm::distance(cube.calcCenter(), viewPosition) + MIN_VISIBLE_DISTANCE;
-                                    float apparentAngle = cube.getScale() / distance;
-                                    if (apparentAngle > MIN_ENTITY_APPARENT_ANGLE * lodScaleFactor) {
+                                    float angularDiameter = cube.getScale() / distance;
+                                    if (angularDiameter > MIN_ENTITY_ANGULAR_DIAMETER * lodScaleFactor) {
                                         float priority = _conicalView.computePriority(cube);
                                         _sendQueue.push(PrioritizedEntity(entity, priority));
                                         _entitiesInQueue.insert(entity.get());
@@ -346,8 +346,8 @@ void EntityTreeSendThread::startNewTraversal(const ViewFrustum& view, EntityTree
                         if (_traversal.getCurrentView().cubeIntersectsKeyhole(cube)) {
                             // See the DiffTraversal::First case for an explanation of the "entity is too small" check
                             float distance = glm::distance(cube.calcCenter(), viewPosition) + MIN_VISIBLE_DISTANCE;
-                            float apparentAngle = cube.getScale() / distance;
-                            if (apparentAngle > MIN_ENTITY_APPARENT_ANGLE * lodScaleFactor) {
+                            float angularDiameter = cube.getScale() / distance;
+                            if (angularDiameter > MIN_ENTITY_ANGULAR_DIAMETER * lodScaleFactor) {
                                 if (!_traversal.getCompletedView().cubeIntersectsKeyhole(cube)) {
                                     float priority = _conicalView.computePriority(cube);
                                     _sendQueue.push(PrioritizedEntity(entity, priority));
@@ -355,8 +355,8 @@ void EntityTreeSendThread::startNewTraversal(const ViewFrustum& view, EntityTree
                                 } else {
                                     // If this entity was skipped last time because it was too small, we still need to send it
                                     distance = glm::distance(cube.calcCenter(), completedViewPosition) + MIN_VISIBLE_DISTANCE;
-                                    apparentAngle = cube.getScale() / distance;
-                                    if (apparentAngle <= MIN_ENTITY_APPARENT_ANGLE * completedLODScaleFactor) {
+                                    angularDiameter = cube.getScale() / distance;
+                                    if (angularDiameter <= MIN_ENTITY_ANGULAR_DIAMETER * completedLODScaleFactor) {
                                         // this object was skipped in last completed traversal
                                         float priority = _conicalView.computePriority(cube);
                                         _sendQueue.push(PrioritizedEntity(entity, priority));
diff --git a/libraries/entities/src/DiffTraversal.cpp b/libraries/entities/src/DiffTraversal.cpp
index a2923c003a..9a48028045 100644
--- a/libraries/entities/src/DiffTraversal.cpp
+++ b/libraries/entities/src/DiffTraversal.cpp
@@ -44,8 +44,8 @@ void DiffTraversal::Waypoint::getNextVisibleElementFirstTime(DiffTraversal::Visi
                     } else if (view.viewFrustum.cubeIntersectsKeyhole(nextElement->getAACube())) {
                         // check for LOD truncation
                         float distance = glm::distance(view.viewFrustum.getPosition(), nextElement->getAACube().calcCenter()) + MIN_VISIBLE_DISTANCE;
-                        float apparentAngle = nextElement->getAACube().getScale() / distance;
-                        if (apparentAngle > MIN_ELEMENT_APPARENT_ANGLE * view.lodScaleFactor) {
+                        float angularDiameter = nextElement->getAACube().getScale() / distance;
+                        if (angularDiameter > MIN_ELEMENT_ANGULAR_DIAMETER * view.lodScaleFactor) {
                             next.element = nextElement;
                             return;
                         }
@@ -84,8 +84,8 @@ void DiffTraversal::Waypoint::getNextVisibleElementRepeat(
                     } else {
                         // check for LOD truncation
                         float distance = glm::distance(view.viewFrustum.getPosition(), nextElement->getAACube().calcCenter()) + MIN_VISIBLE_DISTANCE;
-                        float apparentAngle = nextElement->getAACube().getScale() / distance;
-                        if (apparentAngle > MIN_ELEMENT_APPARENT_ANGLE * view.lodScaleFactor) {
+                        float angularDiameter = nextElement->getAACube().getScale() / distance;
+                        if (angularDiameter > MIN_ELEMENT_ANGULAR_DIAMETER * view.lodScaleFactor) {
                             ViewFrustum::intersection intersection = view.viewFrustum.calculateCubeKeyholeIntersection(nextElement->getAACube());
                             if (intersection != ViewFrustum::OUTSIDE) {
                                 next.element = nextElement;
@@ -121,8 +121,8 @@ void DiffTraversal::Waypoint::getNextVisibleElementDifferential(DiffTraversal::V
                     AACube cube = nextElement->getAACube();
                     // check for LOD truncation
                     float distance = glm::distance(view.viewFrustum.getPosition(), cube.calcCenter()) + MIN_VISIBLE_DISTANCE;
-                    float apparentAngle = cube.getScale() / distance;
-                    if (apparentAngle > MIN_ELEMENT_APPARENT_ANGLE * view.lodScaleFactor) {
+                    float angularDiameter = cube.getScale() / distance;
+                    if (angularDiameter > MIN_ELEMENT_ANGULAR_DIAMETER * view.lodScaleFactor) {
                         if (view.viewFrustum.calculateCubeKeyholeIntersection(cube) != ViewFrustum::OUTSIDE) {
                             next.element = nextElement;
                             next.intersection = ViewFrustum::OUTSIDE;
diff --git a/libraries/octree/src/OctreeUtils.h b/libraries/octree/src/OctreeUtils.h
index 122d82e267..7819db852c 100644
--- a/libraries/octree/src/OctreeUtils.h
+++ b/libraries/octree/src/OctreeUtils.h
@@ -27,11 +27,11 @@ float boundaryDistanceForRenderLevel(unsigned int renderLevel, float voxelSizeSc
 
 float getAccuracyAngle(float octreeSizeScale, int boundaryLevelAdjust);
 
-// MIN_ELEMENT_APPARENT_ANGLE = angular diameter of 1x1x1m cube at 400m = sqrt(3) / 400 = 0.0043301f;
-const float MIN_ELEMENT_APPARENT_ANGLE = 0.0043301f;
+// MIN_ELEMENT_ANGULAR_DIAMETER = angular diameter of 1x1x1m cube at 400m = sqrt(3) / 400 = 0.0043301f
+const float MIN_ELEMENT_ANGULAR_DIAMETER = 0.0043301f;
 // NOTE: the entity bounding cube is larger than the smallest possible containing octree element by sqrt(3)
 const float SQRT_THREE = 1.73205080f;
-const float MIN_ENTITY_APPARENT_ANGLE = MIN_ELEMENT_APPARENT_ANGLE * SQRT_THREE;
+const float MIN_ENTITY_ANGULAR_DIAMETER = MIN_ELEMENT_ANGULAR_DIAMETER * SQRT_THREE;
 const float MIN_VISIBLE_DISTANCE = 0.0001f; // helps avoid divide-by-zero check
 
 #endif // hifi_OctreeUtils_h