help-utils/gradient.py at master · danila-schelkov/help-utils · 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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
class Gradient:
    class Frame:
        def __init__(self, r: int = 0, g: int = 0, b: int = 0, check_borders: bool = True):
            if check_borders:
                if r > 255:
                    r = 255
                elif r < 0:
                    r = 0
                if g > 255:
                    g = 255
                elif g < 0:
                    g = 0
                if b > 255:
                    b = 255
                elif b < 0:
                    b = 0

            self.r = r
            self.g = g
            self.b = b

        def __mul__(self, other):
            if isinstance(other, float) or isinstance(other, int):
                r = int(self.r * other)
                g = int(self.g * other)
                b = int(self.b * other)

                frame = Gradient.Frame(r, g, b, False)
                return frame

        def __add__(self, other):
            r = self.r + other.r
            g = self.g + other.g
            b = self.b + other.b

            return Gradient.Frame(r, g, b)

        def __sub__(self, other):
            r = self.r - other.r
            g = self.g - other.g
            b = self.b - other.b

            return Gradient.Frame(r, g, b)

        def __eq__(self, other):
            return self.r + self.g + self.b == other.r + other.g + other.b

        def __ge__(self, other):
            return self > other or self == other

        def __le__(self, other):
            return self < other or self == other

        def __gt__(self, other):
            return self.r + self.g + self.b >= other.r + other.g + other.b

        def __lt__(self, other):
            return not (self > other)

        def __xor__(self, other):
            r = self.r - other.r
            g = self.g - other.g
            b = self.b - other.b

            return Gradient.Frame(r, g, b, False)

        def __or__(self, other):
            r = max(self.r, other.r) - min(self.r, other.r)
            g = max(self.g, other.g) - min(self.g, other.g)
            b = max(self.b, other.b) - min(self.b, other.b)

            return Gradient.Frame(r, g, b)

        def __bytes__(self):
            return self.r.to_bytes(1, 'big') + self.g.to_bytes(1, 'big') + self.b.to_bytes(1, 'big')

        def __str__(self):
            return self.__bytes__().hex()

        def __repr__(self):
            return str(self)

    def __init__(self):
        self.frames = []

    def create_frame(self, r: int = 0, g: int = 0, b: int = 0):
        """Creates and adds a frame"""
        self.add_frame(Gradient.Frame(r, g, b))

    def add_frame(self, frame: Frame):
        """Add a frame (color) to frames list"""
        self.frames.append(frame)

    def smooth(self, length: int):
        """Helps get the gradient you want"""
        if len(self.frames) > length:
            return self.frames[:length]

        if len(self.frames) > 1:
            smoothed = []

            transitions_count = len(self.frames)
            frames_in_transition = int(length / (transitions_count - 1) + 0.5)  # math.ceil
            for transition_index in range(transitions_count - 1):
                frame_slice = self.frames[transition_index:transition_index+2]

                min_frame = min(frame_slice)
                max_frame = max(frame_slice)
                difference = max_frame ^ min_frame
                frame_to_add = min_frame

                for x in range(frames_in_transition):
                    transition_level = x / (frames_in_transition - 1) if frames_in_transition > 1 else 0
                    if frame_slice.index(min_frame) == 1:
                        frame_to_add = max_frame
                        transition_level *= -1

                    smoothed.append(frame_to_add + difference * transition_level)
            return smoothed

        return self.frames

    def apply(self, text: str, style: int = 0):
        """Applies a gradient to text"""
        result = ''
        colors = self.smooth(len(text))
        for char_index in range(len(text)):
            color = colors[char_index % len(colors)]
            if style == 0:
                result += f'<c{color}>{text[char_index]}'
            elif style == 1:
                result += f'<font color="#{color}">{text[char_index]}</font>'

        if style == 0:
            result += '</c>'
        return result


if __name__ == '__main__':
    gradient = Gradient()
    gradient.create_frame()
    gradient.create_frame(255, 255, 255)
    print(gradient.apply('f' * 1000, 1))  # You can put here any string