Exemple #1
0
    def generate_path(self):
        """Generate the path for the profile operation"""

        part_boundbox = self.part_segment_group.boundbox()
        x_min = self.stock.x_min - self.extra_dia * 0.5 - self.clearance
        x_max = 0 - self.min_dia * 0.5
        z_max = self.stock.z_max + self.start_offset

        self.clearing_paths = []
        length = z_max - part_boundbox.z_max + self.stock_to_leave
        step_over = self.step_over
        line_count = math.ceil(length / step_over)
        zstart = part_boundbox.z_max + step_over * line_count + self.stock_to_leave

        # build list of segments
        segmentgroup = SegmentGroup()
        # TODO: Move the final pass to finishing passes for a slower pass
        counter = 0
        while counter < line_count + 1:
            zpt = zstart - counter * self.step_over
            pt1 = Point(x_min, 0, zpt)
            pt2 = Point(x_max, 0, zpt)
            path_line = Segment(pt1, pt2)
            seg = path_line
            segmentgroup.add_segment(seg)

            pt3 = pt2.project(self.leadout_angle, self.step_over)
            leadout = Segment(pt2, pt3)
            segmentgroup.add_segment(leadout)

            counter += 1

        self.clearing_paths.append(segmentgroup)
Exemple #2
0
class test_point(unittest.TestCase):
    """Test for point.py"""
    def setUp(self):
        self.pt1 = Point(0, 0, 0)
        self.pt2 = Point(100, 100, 100)
        self.pt3 = Point(150, 130, 200)
        self.pt4 = Point(200, 200, 200)
        self.pt5 = Point(-100, 0, 100)
        self.pt6 = Point(0, 100, 200)
        self.pt7 = Point(-200, -200, -200)
        self.pt8 = Point(-400, -400, -400)
        self.pt9 = Point(-200, -200, -200)
        self.pt10 = Point(200, 200, 200)

    def test_distance_to(self):
        distance = self.pt1.distance_to(self.pt2)
        self.assertEqual(distance, 173.20508075688772)

    def test_angle_to(self):
        angle = self.pt1.angle_to(self.pt2)
        self.assertEqual(angle, 45)

    def test_nearest(self):
        pts = [self.pt2, self.pt3]
        nearest = self.pt1.nearest(pts)
        self.assertEqual(nearest, self.pt2)

    def test_is_same_return_false(self):
        same = self.pt1.is_same(self.pt2)
        self.assertFalse(same)

    def test_is_same_return_true(self):
        same = self.pt1.is_same(self.pt1)
        self.assertTrue(same)

    def test_sub(self):
        sub = self.pt4.sub(self.pt2)
        self.assertEqual(sub.X, self.pt2.X)
        self.assertEqual(sub.Y, self.pt2.Y)
        self.assertEqual(sub.Z, self.pt2.Z)

        subNegative = self.pt7.add(self.pt7)
        self.assertEqual(subNegative.X, self.pt8.X)
        self.assertEqual(subNegative.Y, self.pt8.Y)
        self.assertEqual(subNegative.Z, self.pt8.Z)

    def test_add(self):
        add = self.pt2.add(self.pt2)
        self.assertEqual(add.X, self.pt4.X)
        self.assertEqual(add.Y, self.pt4.Y)
        self.assertEqual(add.Z, self.pt4.Z)

        addNegative = self.pt5.add(self.pt2)
        self.assertEqual(addNegative.X, self.pt6.X)
        self.assertEqual(addNegative.Y, self.pt6.Y)
        self.assertEqual(addNegative.Z, self.pt6.Z)

    def test_multiply(self):
        multiply = self.pt2.multiply(0)
        self.assertEqual(multiply.X, self.pt1.X)
        self.assertEqual(multiply.Y, self.pt1.Y)
        self.assertEqual(multiply.Z, self.pt1.Z)

        multiplyNegative = self.pt7.multiply(1)
        self.assertEqual(multiplyNegative.X, self.pt7.X)
        self.assertEqual(multiplyNegative.Y, self.pt7.Y)
        self.assertEqual(multiplyNegative.Z, self.pt7.Z)

    def test_rotate(self):
        rotate = self.pt2.rotate(90)
        self.assertEqual(rotate.X, 100)
        self.assertEqual(rotate.Y, 100)
        self.assertEqual(rotate.Z, -100)

    def test_mid(self):
        mid = self.pt2.mid(self.pt4)
        self.assertEqual(mid.X, 150)
        self.assertEqual(mid.Y, 150)
        self.assertEqual(mid.Z, 150)

    def test_project(self):
        projected = self.pt1.project(270, 5)
        self.assertEqual(projected.X, self.pt1.X)
        self.assertEqual(projected.Y, self.pt1.Y)
        self.assertEqual(projected.Z, -5)
Exemple #3
0
class test_point(unittest.TestCase):
    """Test for point.py"""
    def setUp(self):
        self.pt1 = Point(0, 0, 0)
        self.pt2 = Point(100, 100, 100)
        self.pt3 = Point(150, 130, 200)
        self.pt4 = Point(200, 200, 200)
        self.pt5 = Point(-100, 0, 100)
        self.pt6 = Point(0, 100, 200)
        self.pt7 = Point(-200, -200, -200)
        self.pt8 = Point(-400, -400, -400)
        self.pt9 = Point(-200, -200, -200)
        self.pt10 = Point(200, 200, 200)

    def test_distance_to(self):
        distance = self.pt1.distance_to(self.pt2)
        self.assertEqual(distance, 173.20508075688772)

    def test_angle_to(self):

        angle = self.pt1.angle_to(Point(0, 0, 100))
        self.assertEqual(angle, 0)

        angle = self.pt1.angle_to(Point(100, 0, 100))
        self.assertEqual(angle, 45)

        angle = self.pt1.angle_to(Point(100, 0, 0))
        self.assertEqual(angle, 90)

        angle = self.pt1.angle_to(Point(100, 0, -100))
        self.assertEqual(angle, 135)

        angle = self.pt1.angle_to(Point(0, 0, -100))
        self.assertEqual(angle, 180)

        angle = self.pt1.angle_to(Point(-100, 0, -100))
        self.assertEqual(angle, 225)

        angle = self.pt1.angle_to(Point(-100, 0, 0))
        self.assertEqual(angle, 270)

        angle = self.pt1.angle_to(Point(-100, 0, 100))
        self.assertEqual(angle, 315)

    def test_nearest(self):
        pts = [self.pt2, self.pt3]
        nearest = self.pt1.nearest(pts)
        self.assertEqual(nearest, self.pt2)

    def test_is_same_return_false(self):
        same = self.pt1.is_same(self.pt2)
        self.assertFalse(same)

    def test_is_same_return_true(self):
        same = self.pt1.is_same(self.pt1)
        self.assertTrue(same)

    def test_sub(self):
        sub = self.pt4.sub(self.pt2)
        self.assertEqual(sub.X, self.pt2.X)
        self.assertEqual(sub.Y, self.pt2.Y)
        self.assertEqual(sub.Z, self.pt2.Z)

        subNegative = self.pt7.add(self.pt7)
        self.assertEqual(subNegative.X, self.pt8.X)
        self.assertEqual(subNegative.Y, self.pt8.Y)
        self.assertEqual(subNegative.Z, self.pt8.Z)

    def test_add(self):
        add = self.pt2.add(self.pt2)
        self.assertEqual(add.X, self.pt4.X)
        self.assertEqual(add.Y, self.pt4.Y)
        self.assertEqual(add.Z, self.pt4.Z)

        addNegative = self.pt5.add(self.pt2)
        self.assertEqual(addNegative.X, self.pt6.X)
        self.assertEqual(addNegative.Y, self.pt6.Y)
        self.assertEqual(addNegative.Z, self.pt6.Z)

    def test_multiply(self):
        multiply = self.pt2.multiply(0)
        self.assertEqual(multiply.X, self.pt1.X)
        self.assertEqual(multiply.Y, self.pt1.Y)
        self.assertEqual(multiply.Z, self.pt1.Z)

        multiplyNegative = self.pt7.multiply(1)
        self.assertEqual(multiplyNegative.X, self.pt7.X)
        self.assertEqual(multiplyNegative.Y, self.pt7.Y)
        self.assertEqual(multiplyNegative.Z, self.pt7.Z)

    def test_lerp(self):
        lerp = self.pt1.lerp(self.pt2, 0.5)
        self.assertEqual(lerp.X, 50)
        self.assertEqual(lerp.Y, 50)
        self.assertEqual(lerp.Z, 50)

    def test_normalise_to(self):
        normal = self.pt1.normalise_to(Point(100, 0, 100))
        self.assertEqual(normal.X, 0.7071067811865475)
        self.assertEqual(normal.Y, 0)
        self.assertEqual(normal.Z, 0.7071067811865475)

        normal = self.pt1.normalise_to(self.pt1)
        self.assertEqual(normal.X, 0)
        self.assertEqual(normal.Y, 0)
        self.assertEqual(normal.Z, 0)

    def test_rotate(self):
        rotate = self.pt2.rotate(90)
        self.assertEqual(rotate.X, -100)
        self.assertEqual(rotate.Y, 100)
        self.assertEqual(rotate.Z, 100)

    def test_mid(self):
        mid = self.pt2.mid(self.pt4)
        self.assertEqual(mid.X, 150)
        self.assertEqual(mid.Y, 150)
        self.assertEqual(mid.Z, 150)

    def test_project(self):
        projected = self.pt1.project(0, 5)
        self.assertEqual(projected.X, 0)
        self.assertEqual(projected.Y, 0)
        self.assertEqual(projected.Z, 5)

        projected = self.pt1.project(45, 5)
        self.assertEqual(projected.X, 3.53553)
        self.assertEqual(projected.Y, 0)
        self.assertEqual(projected.Z, 3.53553)

        projected = self.pt1.project(90, 5)
        self.assertEqual(projected.X, 5)
        self.assertEqual(projected.Y, 0)
        self.assertEqual(projected.Z, 0)

        projected = self.pt1.project(135, 5)
        self.assertEqual(projected.X, 3.53553)
        self.assertEqual(projected.Y, 0)
        self.assertEqual(projected.Z, -3.53553)

        projected = self.pt1.project(180, 5)
        self.assertEqual(projected.X, 0)
        self.assertEqual(projected.Y, 0)
        self.assertEqual(projected.Z, -5)

        projected = self.pt1.project(225, 5)
        self.assertEqual(projected.X, -3.53553)
        self.assertEqual(projected.Y, 0)
        self.assertEqual(projected.Z, -3.53553)

        projected = self.pt1.project(270, 5)
        self.assertEqual(projected.X, -5)
        self.assertEqual(projected.Y, 0)
        self.assertEqual(projected.Z, 0)