G-Cod3r/CAM_methods.py at main · Nikongen/G-Cod3r · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import numpy as np

from CAM_Interface import CAM_Interface

"""
Bibliothek mit grundlegenden Strukturen
"""
class CAM_structures():

    def __init__(self, interface: CAM_Interface):
        """
        Constructor for CAM methods. Needs object with CAM_Interface

        :param interface: CAM_Interface object
        """
        self._interface = interface

    def square_aperture(self, outer: float, inner: float, overlap=.25):
        """
        Hollow square aperture.

        :param outer: Outer length in mm
        :param inner: Inner length in mm
        :param overlap: layer overlap in percent
        """
        a = outer
        b = self._interface.get_print_property('layer_width') * (1-overlap)
        while a > inner:
            self._interface.rel_print(x=a)
            self._interface.rel_print(y=a)
            a -= b
            self._interface.rel_print(x=-a)
            self._interface.rel_print(y=-a)
            a -= b

    def rect_aperture(self, outer_x: float, outer_y: float, inner_x: float, inner_y: float, overlap=.25):
        """
        Hollow rectangle aperture.

        outer_x/inner_x > outer_y/inner_y

        Start at edge with smallest x,y coordinates
        :param outer_x: Seitenlänge außen in mm
        :param outer_y: Seitenlänge außen in mm
        :param inner_x: Seitenlänge Aussparung/Loch in mm
        :param inner_y: Seitenlänge Aussparung/Loch in mm
        :param overlap: Prozentualer überlapp der Schichten
        """
        start_pos = self._interface.get_pos()
        x = (outer_x - inner_x) / 2
        y = (outer_y - inner_y) / 2
        # Rechteck Rahmen um Gitter drucken. Sobald kleinere Breite erreicht, die größeren Blöcke einzeln drucken
        curr_x = inner_x
        curr_y = inner_y
        stride = self._interface.get_print_property('layer_width') * (1 - overlap)
        # Innen anfangen und nach außen schnecken
        while curr_y < outer_y:
            self._interface.rel_print(x=curr_x)
            self._interface.rel_print(y=curr_y)
            curr_x += stride
            curr_y += stride
            self._interface.rel_print(x=-curr_x)
            if curr_y >= outer_y:
                break
            self._interface.rel_print(y=-curr_y)
            curr_x += stride
            curr_y += stride
        # Ende "inneres Rechteck" an Startecke nur weiter außen
        # Position anfahren
        block1_x = start_pos[0] - (outer_y - inner_y) / 2
        block1_y = start_pos[1] - (outer_y - inner_y) / 2
        self._interface.abs_move(x=block1_x, absolute=True)
        self._interface.abs_move(y=block1_y, absolute=True)
        w = (outer_x - (inner_x + (outer_y - inner_y))) / 2
        curr_w = 0
        while curr_w < w:
            self._interface.rel_print(y=outer_y)
            curr_w += stride
            if curr_w >= w:
                break
            self._interface.rel_print(x=-stride)
            self._interface.rel_print(y=-outer_y)
            curr_w += stride
            if curr_w >= w:
                break
            self._interface.rel_print(x=-stride)
        # Anderen Randblock zeichnen
        # Position anfahren
        block2_x = start_pos[0] + inner_x + (outer_y-inner_y)/2 + stride/2
        block2_y = start_pos[1] - (outer_y-inner_y)/2
        self._interface.abs_move(x=block2_x, absolute=True)
        self._interface.abs_move(y=block2_y, absolute=True)
        curr_w = 0
        while curr_w < w:
            self._interface.rel_print(y=curr_y)
            curr_w += stride
            if curr_w >= w:
                break
            self._interface.rel_print(x=stride)
            self._interface.rel_print(y=-curr_y)
            curr_w += stride
            if curr_w >= w:
                break
            self._interface.rel_print(x=stride)


    def lattice(self, n: float, d: float, length: float):
        """
        Print lattice according to parameters.

        :param n: number of bars
        :param d: distance btwn bars
        :param length: length of bars
        :return:
        """
        a = n
        while a > 0:
            self._interface.rel_print(x=length)
            self._interface.rel_print(y=d)
            self._interface.rel_print(x=-length)
            self._interface.rel_print(y=d)
            a -= 2 * d