CNCPoint CNCPoint::operator- ( const CNCPoint & rhs ) const
{
CNCPoint result(*this);
result.SetX( X() - rhs.X() );
result.SetY( Y() - rhs.Y() );
result.SetZ( Z() - rhs.Z() );
return(result);
}
bool CNCPoint::operator<( const CNCPoint & rhs ) const
{
if (*this == rhs) return(false);
if (fabs(X() - rhs.X()) > Tolerance())
{
if (X() > rhs.X()) return(false);
if (X() < rhs.X()) return(true);
}
if (fabs(Y() - rhs.Y()) > Tolerance())
{
if (Y() > rhs.Y()) return(false);
if (Y() < rhs.Y()) return(true);
}
if (fabs(Z() - rhs.Z()) > Tolerance())
{
if (Z() > rhs.Z()) return(false);
if (Z() < rhs.Z()) return(true);
}
return(false); // They're equal
} // End equivalence operator
/**
* This method looks through the symbols in the list. If they're PointType objects
* then the object's location is added to the result set. If it's a circle object
* that doesn't intersect any other element (selected) then add its centre to
* the result set. Finally, find the intersections of all of these elements and
* add the intersection points to the result vector.
*/
/* static */ std::vector<CNCPoint> CDrilling::FindAllLocations(
ObjList *parent,
const CNCPoint starting_location, // = CNCPoint(0.0, 0.0, 0.0)
const bool sort_locations, // = false
std::list<int> *pToolNumbersReferenced /* = NULL */ )
{
std::vector<CNCPoint> locations;
parent->ReloadPointers(); // Make sure our integer lists have been converted into children first.
// Look to find all intersections between all selected objects. At all these locations, create
// a drilling cycle.
std::list<HeeksObj *> lhs_children;
std::list<HeeksObj *> rhs_children;
for (HeeksObj *lhsPtr = parent->GetFirstChild(); lhsPtr != NULL; lhsPtr = parent->GetNextChild())
{
lhs_children.push_back( lhsPtr );
rhs_children.push_back( lhsPtr );
}
for (std::list<HeeksObj *>::iterator itLhs = lhs_children.begin(); itLhs != lhs_children.end(); itLhs++)
{
HeeksObj *lhsPtr = *itLhs;
bool l_bIntersectionsFound = false; // If it's a circle and it doesn't
// intersect anything else, we want to know
// about it.
if (lhsPtr->GetType() == PointType)
{
double pos[3];
lhsPtr->GetStartPoint(pos);
// Copy the results in ONLY if each point doesn't already exist.
if (std::find( locations.begin(), locations.end(), CNCPoint( pos ) ) == locations.end())
{
locations.push_back( CNCPoint( pos ) );
} // End if - then
continue; // No need to intersect a point with anything.
} // End if - then
for (std::list<HeeksObj *>::iterator itRhs = rhs_children.begin(); itRhs != rhs_children.end(); itRhs++)
{
HeeksObj *rhsPtr = *itRhs;
if (lhsPtr == rhsPtr) continue;
if (lhsPtr->GetType() == PointType) continue; // No need to intersect a point type.
std::list<double> results;
if ((lhsPtr != NULL) && (rhsPtr != NULL) && (lhsPtr->Intersects( rhsPtr, &results )))
{
l_bIntersectionsFound = true;
while (((results.size() % 3) == 0) && (results.size() > 0))
{
CNCPoint intersection;
intersection.SetX( *(results.begin()) );
results.erase(results.begin());
intersection.SetY( *(results.begin()) );
results.erase(results.begin());
intersection.SetZ( *(results.begin()) );
results.erase(results.begin());
// Copy the results in ONLY if each point doesn't already exist.
if (std::find( locations.begin(), locations.end(), intersection ) == locations.end())
{
locations.push_back(intersection);
} // End if - then
} // End while
} // End if - then
} // End for
if (! l_bIntersectionsFound)
{
// This element didn't intersect anything else. If it's a circle
// then add its centre point to the result set.
if (lhsPtr->GetType() == CircleType)
{
double pos[3];
if ((lhsPtr != NULL) && (heeksCAD->GetArcCentre( lhsPtr, pos )))
{
// Copy the results in ONLY if each point doesn't already exist.
if (std::find( locations.begin(), locations.end(), CNCPoint( pos ) ) == locations.end())
{
locations.push_back( CNCPoint( pos ) );
} // End if - then
} // End if - then
} // End if - then
if (lhsPtr->GetType() == SketchType)
{
CBox bounding_box;
lhsPtr->GetBox( bounding_box );
double pos[3];
bounding_box.Centre(pos);
// Copy the results in ONLY if each point doesn't already exist.
if (std::find( locations.begin(), locations.end(), CNCPoint( pos ) ) == locations.end())
{
locations.push_back( CNCPoint( pos ) );
} // End if - then
} // End if - then
if (lhsPtr->GetType() == ProfileType)
{
std::vector<CNCPoint> starting_points;
CMachineState machine;
#ifndef STABLE_OPS_ONLY
CFixture perfectly_aligned_fixture(NULL,CFixture::G54, false, 0.0);
machine.Fixture(perfectly_aligned_fixture);
#endif
// to do, make this get the starting point again
//((CProfile *)lhsPtr)->AppendTextToProgram( starting_points, &machine );
// Copy the results in ONLY if each point doesn't already exist.
for (std::vector<CNCPoint>::const_iterator l_itPoint = starting_points.begin(); l_itPoint != starting_points.end(); l_itPoint++)
{
if (std::find( locations.begin(), locations.end(), *l_itPoint ) == locations.end())
{
locations.push_back( *l_itPoint );
} // End if - then
} // End for
} // End if - then
if (lhsPtr->GetType() == DrillingType)
{
// Ask the Drilling object what reference points it uses.
if ((((COp *) lhsPtr)->m_tool_number > 0) && (pToolNumbersReferenced != NULL))
{
pToolNumbersReferenced->push_back( ((COp *) lhsPtr)->m_tool_number );
} // End if - then
std::vector<CNCPoint> holes = CDrilling::FindAllLocations((CDrilling *)lhsPtr, starting_location, false, pToolNumbersReferenced);
for (std::vector<CNCPoint>::const_iterator l_itHole = holes.begin(); l_itHole != holes.end(); l_itHole++)
{
if (std::find( locations.begin(), locations.end(), *l_itHole ) == locations.end())
{
locations.push_back( *l_itHole );
} // End if - then
} // End for
} // End if - then
#ifndef STABLE_OPS_ONLY
if (lhsPtr->GetType() == CounterBoreType)
{
std::vector<CNCPoint> holes = CDrilling::FindAllLocations((CCounterBore *)lhsPtr, starting_location, false, NULL);
for (std::vector<CNCPoint>::const_iterator l_itHole = holes.begin(); l_itHole != holes.end(); l_itHole++)
{
if (std::find( locations.begin(), locations.end(), *l_itHole ) == locations.end())
{
locations.push_back( *l_itHole );
} // End if - then
} // End for
} // End if - then
#endif
} // End if - then
} // End for
if (sort_locations)
{
// This drilling cycle has the 'sort' option turned on.
//
// If the sorting option is turned off then the points need to be returned in order of the m_symbols list. One day,
// we will allow the operator to re-order the m_symbols list by using a drag-n-drop operation on the sub-elements
// in the menu. When this is done, the operator's decision as to order should be respected. Until then, we can
// use the 'sort' option in the drilling cycle's parameters.
for (std::vector<CNCPoint>::iterator l_itPoint = locations.begin(); l_itPoint != locations.end(); l_itPoint++)
{
if (l_itPoint == locations.begin())
{
// It's the first point.
CNCPoint reference_location(0.0, 0.0, 0.0);
reference_location = starting_location;
sort_points_by_distance compare( reference_location );
std::sort( locations.begin(), locations.end(), compare );
} // End if - then
else
{
// We've already begun. Just sort based on the previous point's location.
std::vector<CNCPoint>::iterator l_itNextPoint = l_itPoint;
l_itNextPoint++;
if (l_itNextPoint != locations.end())
{
sort_points_by_distance compare( *l_itPoint );
std::sort( l_itNextPoint, locations.end(), compare );
} // End if - then
} // End if - else
} // End for
} // End if - then
return(locations);
} // End FindAllLocations() method
std::list< CNCPoint > CDrilling::DrillBitVertices( const CNCPoint & origin, const double radius, const double length ) const
{
std::list<CNCPoint> top, spiral, bottom, countersink, result;
double flutePitch = 5.0; // 5mm of depth per spiral of the drill bit's flute.
double countersinkDepth = -1 * radius * tan(31.0); // this is the depth of the countersink cone at the end of the drill bit. (for a typical 118 degree bevel)
unsigned int numPoints = 20; // number of points in one circle (360 degrees) i.e. how smooth do we want the graphics
const double pi = 3.1415926;
double alpha = 2 * pi / numPoints;
// Get a circle at the top of the dill bit's path
top = PointsAround( origin, radius, numPoints );
top.push_back( *(top.begin()) ); // Close the circle
double depthPerItteration;
countersinkDepth = -1 * radius * tan(31.0); // For a typical (118 degree bevel on the drill bit tip)
unsigned int l_iNumItterations = numPoints * (length / flutePitch);
depthPerItteration = (length - countersinkDepth) / l_iNumItterations;
// Now generate the spirals.
unsigned int i = 0;
while( i++ < l_iNumItterations )
{
double theta = alpha * i;
CNCPoint pointOnCircle( cos( theta ) * radius, sin( theta ) * radius, 0 );
pointOnCircle += origin;
// And spiral down as we go.
pointOnCircle.SetZ( pointOnCircle.Z() - (depthPerItteration * i) );
spiral.push_back(pointOnCircle);
} // End while
// And now the countersink at the bottom of the drill bit.
i = 0;
while( i++ < numPoints )
{
double theta = alpha * i;
CNCPoint topEdge( cos( theta ) * radius, sin( theta ) * radius, 0 );
// This is at the top edge of the countersink
topEdge.SetX( topEdge.X() + origin.X() );
topEdge.SetY( topEdge.Y() + origin.Y() );
topEdge.SetZ( origin.Z() - (length - countersinkDepth) );
spiral.push_back(topEdge);
// And now at the very point of the countersink
CNCPoint veryTip( origin );
veryTip.SetZ( (origin.Z() - length) );
spiral.push_back(veryTip);
spiral.push_back(topEdge);
} // End while
std::copy( top.begin(), top.end(), std::inserter( result, result.begin() ) );
std::copy( spiral.begin(), spiral.end(), std::inserter( result, result.end() ) );
std::copy( countersink.begin(), countersink.end(), std::inserter( result, result.end() ) );
return(result);
} // End DrillBitVertices() routine
bool CNCPoint::operator==( const CNCPoint & rhs ) const
{
// We use the sum of both point's tolerance values.
return(Distance(rhs) < (Tolerance() + rhs.Tolerance()));
} // End equivalence operator
