seolpyo-mplchart 1.3.1.2__py3-none-any.whl → 1.4.0__py3-none-any.whl

seolpyo_mplchart/_draw.py

@@ -10,16 +10,12 @@ from ._base import Base
 
 
 class Mixin:
-    def add_artist(self):
-        "This method work when ```__init__()``` run."
-        return
-
     def draw_artist(self):
         "This method work before ```figure.canvas.blit()```."
         return
 
-    def generate_data(self):
-        "This method work before create segments."
+    def on_change_xlim(self, xmin, xmax, simpler=False, set_ma=True):
+        "This method work if xlim change."
         return
 
     def on_draw(self, e):
@@ -30,10 +26,6 @@ class Mixin:
         "If draw pick active, This method work."
         return
 
-    def set_segment(self, xmin, xmax, simpler=False, set_ma=True):
-        "This method work if xlim change."
-        return
-
 
 class CollectionMixin(Base):
     facecolor_volume, edgecolor_volume = ('#1f77b4', 'k')
@@ -46,23 +38,23 @@ class CollectionMixin(Base):
         return
 
     def _add_collection(self):
-        self.collection_ma = LineCollection([], animated=True, linewidths=1)
-        self.ax_price.add_collection(self.collection_ma)
+        self.artist_watermark = Text(
+            x=0.5, y=0.5, text=self.watermark,
+            animated=True,
+            fontsize=20, color=self.color_tick_label, alpha=0.2,
+            horizontalalignment='center', verticalalignment='center',
+            transform=self.ax_price.transAxes
+        )
+        self.ax_price.add_artist(self.artist_watermark)
 
         self.collection_candle = LineCollection([], animated=True, linewidths=0.8)
         self.ax_price.add_collection(self.collection_candle)
 
+        self.collection_ma = LineCollection([], animated=True, linewidths=1)
+        self.ax_price.add_collection(self.collection_ma)
+
         self.collection_volume = LineCollection([], animated=True, linewidths=1)
         self.ax_volume.add_collection(self.collection_volume)
-
-        x = (self.adjust['right']-self.adjust['left']) / 2
-        self.text_watermark = Text(
-            x=x, y=0.51, text=self.watermark,
-            animated=True,
-            fontsize=20, color=self.color_tick_label, alpha=0.2,
-            horizontalalignment='center', verticalalignment='center',
-        )
-        self.figure.add_artist(self.text_watermark)
         return
 
     def change_background_color(self, color):
@@ -86,7 +78,7 @@ class CollectionMixin(Base):
         return
 
     def change_text_color(self, color):
-        self.text_watermark.set_color(color)
+        self.artist_watermark.set_color(color)
         legends = self.ax_legend.get_legend()
         if legends:
             for i in legends.texts: i.set_color(color)
@@ -95,13 +87,64 @@ class CollectionMixin(Base):
     def change_line_color(self, color): return
 
 
+class DrawMixin(CollectionMixin):
+    candle_on_ma = True
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self._connect_event()
+        return
+
+    def _connect_event(self):
+        self.figure.canvas.mpl_connect('draw_event', lambda x: self._on_draw(x))
+        return
+
+    def _on_draw(self, e):
+        self._draw_artist()
+        self.figure.canvas.blit()
+        return
+
+    def _draw_artist(self):
+        self._draw_ax_price()
+        self._draw_ax_volume()
+        return
+
+    def _draw_ax_price(self):
+        renderer = self.figure.canvas.renderer
+
+        self.ax_price.xaxis.draw(renderer)
+        self.ax_price.yaxis.draw(renderer)
+
+        if self.candle_on_ma:
+            self.collection_ma.draw(renderer)
+            self.collection_candle.draw(renderer)
+        else:
+            self.collection_candle.draw(renderer)
+            self.collection_ma.draw(renderer)
+
+        if self.watermark:
+            self.artist_watermark.set_text(self.watermark)
+            self.artist_watermark.draw(renderer)
+        return
+
+    def _draw_ax_volume(self):
+        renderer = self.figure.canvas.renderer
+
+        self.ax_volume.xaxis.draw(renderer)
+        self.ax_volume.yaxis.draw(renderer)
+
+        self.collection_volume.draw(renderer)
+        return
+
+
 _set_key = {
     'x', 'zero', 'close_pre', 'ymax_volume',
     'top_candle', 'bottom_candle', 'left_candle', 'right_candle',
     'left_volume', 'right_volume',
 }
 
-class DataMixin(CollectionMixin):
+class DataMixin(DrawMixin):
     df: pd.DataFrame
 
     date = 'date'
@@ -114,8 +157,8 @@ class DataMixin(CollectionMixin):
     color_flat = 'k'
     color_up_down, color_down_up = ('w', 'w')
 
-    color_volume_up, color_volume_down = ('#FF4D4D', '#5CA8F4')
-    color_volume_flat = '#A9A9A9'
+    color_volume_up, color_volume_down = ('#FF5555', '#5CA8F4')
+    color_volume_flat = '#909090'
 
     set_candlecolor, set_volumecolor = (True, True)
 
@@ -168,7 +211,6 @@ class DataMixin(CollectionMixin):
             v = getattr(self, i)
             if v in _set_key: raise Exception(f'you can not set "{i}" to column key.\nself.{i}={v!r}')
 
-
         if not self.set_candlecolor:
             keys = set(df.keys())
             for i in ('facecolor', 'edgecolor', 'facecolor_volume', 'edgecolor_volume',):
@@ -180,23 +222,14 @@ class DataMixin(CollectionMixin):
             for i in ('facecolor_volume', 'edgecolor_volume',):
                 if i not in keys:
                     raise Exception(f'"{i}" column not in DataFrame.\nadd column or set set_volumecolor=True.')
-
         return
 
 
-class SegmentMixin(DataMixin):
-    _visible_ma = set()
-
-    limit_candle = 800
-    limit_wick = 4_000
-    limit_volume = 200
-
+class CandleSegmentMixin(DataMixin):
     color_priceline = 'k'
-    format_ma = '{}일선'
-    # https://matplotlib.org/stable/gallery/color/named_colors.html
-    list_macolor = ('#B22222', '#228B22', '#1E90FF', '#FF8C00', '#4B0082')
+    limit_candle = 800
 
-    def _get_segments(self):
+    def _create_candle_segments(self):
         # 캔들 세그먼트
         segment_candle = self.df[[
             'x', self.high,
@@ -225,28 +258,10 @@ class SegmentMixin(DataMixin):
         segment_priceline = segment_wick = self.df[['x', self.close]].values
         self.segment_priceline = segment_priceline.reshape(1, *segment_wick.shape)
 
-        if self.volume:
-            # 거래량 바 세그먼트
-            segment_volume = self.df[[
-                'left_volume', 'zero',
-                'left_volume', self.volume,
-                'right_volume', self.volume,
-                'right_volume', 'zero',
-            ]].values
-            self.segment_volume = segment_volume.reshape(segment_volume.shape[0], 4, 2)
-
-            # 거래량 심지 세그먼트
-            segment_volume_wick = self.df[[
-                'x', 'zero',
-                'x', self.volume,
-            ]].values
-            self.segment_volume_wick = segment_volume_wick.reshape(segment_volume_wick.shape[0], 2, 2)
-
-        self._get_ma_segment()
-        self._get_color_segment()
+        self._create_candle_color_segments()
         return
 
-    def _get_color_segment(self):
+    def _create_candle_color_segments(self):
         if self.set_candlecolor:
             # 양봉
             self.df.loc[:, ['facecolor', 'edgecolor']] = (self.color_up, self.color_up)
@@ -265,20 +280,48 @@ class SegmentMixin(DataMixin):
 
         self.facecolor_candle = self.df['facecolor'].values
         self.edgecolor_candle = self.df['edgecolor'].values
+        return
 
-        if self.set_volumecolor:
-            # 거래량
-            self.df.loc[:, ['facecolor_volume', 'edgecolor_volume']] = (self.color_volume_up, self.color_volume_up)
-            if self.color_up != self.color_down:
-                # 전일대비 하락
-                self.df.loc[self.df[self.close] < self.df['close_pre'], ['facecolor_volume', 'edgecolor_volume']] = (self.color_volume_down, self.color_volume_down)
-            if self.color_up != self.color_flat:
-                # 전일과 동일
-                self.df.loc[self.df[self.close] == self.df['close_pre'], ['facecolor_volume', 'edgecolor_volume']] = (self.color_volume_flat, self.color_volume_flat)
+    def _set_candle_segments(self, index_start, index_end):
+        self.collection_candle.set_segments(self.segment_candle[index_start:index_end])
+        self.collection_candle.set_facecolor(self.facecolor_candle[index_start:index_end])
+        self.collection_candle.set_edgecolor(self.edgecolor_candle[index_start:index_end])
+        return
 
-        self.facecolor_volume = self.df['facecolor_volume'].values
-        self.edgecolor_volume = self.df['edgecolor_volume'].values
+    def _set_candle_wick_segments(self, index_start, index_end):
+        self.collection_candle.set_segments(self.segment_candle_wick[index_start:index_end])
+        self.collection_candle.set_facecolor([])
+        self.collection_candle.set_edgecolor(self.edgecolor_candle[index_start:index_end])
+        return
+
+    def _set_priceline_segments(self, index_start, index_end):
+        self.collection_candle.set_segments(self.segment_priceline[:, index_start:index_end])
+        self.collection_candle.set_facecolor([])
+        self.collection_candle.set_edgecolor(self.color_priceline)
+        return
+
+
+class MaSegmentMixin(CandleSegmentMixin):
+    format_ma = '{}일선'
+    # https://matplotlib.org/stable/gallery/color/named_colors.html
+    list_macolor = ('#006400', '#8B008B', '#FFA500', '#0000FF', '#FF0000')
+
+    _visible_ma = set()
+
+    def _create_ma_segments(self):
+        # 주가 차트 가격이동평균선
+        key_ma = []
+        for i in reversed(self.list_ma):
+            key_ma.append('x')
+            key_ma.append(f'ma{i}')
+        if key_ma:
+            segment_ma = self.df[key_ma].values
+            self.segment_ma = segment_ma.reshape(segment_ma.shape[0], len(self.list_ma), 2).swapaxes(0, 1)
 
+        self._create_ma_color_segments()
+        return
+
+    def _create_ma_color_segments(self):
         # 기존 legend 제거
         legends = self.ax_legend.get_legend()
         if legends: legends.remove()
@@ -286,7 +329,7 @@ class SegmentMixin(DataMixin):
         self._visible_ma.clear()
 
         list_handle, list_label, list_color = ([], [], [])
-        arr = (0, 1)
+        arr = [0, 1]
         for n, i in enumerate(self.list_ma):
             try: c = self.list_macolor[n]
             except: c = self.color_priceline
@@ -308,106 +351,108 @@ class SegmentMixin(DataMixin):
             for i in legends.legend_handles: i.set_picker(5)
         return
 
-    def _get_ma_segment(self):
-        if not self.list_ma: return
-
-        # 주가 차트 가격이동평균선
-        key_ma = []
-        for i in reversed(self.list_ma):
-            key_ma.append('x')
-            key_ma.append(f'ma{i}')
-        segment_ma = self.df[key_ma].values
-        self.segment_ma = segment_ma.reshape(segment_ma.shape[0], len(self.list_ma), 2).swapaxes(0, 1)
+    def _set_ma_segments(self, index_start, index_end, set_ma):
+        if not set_ma: self.collection_ma.set_segments([])
+        else:
+            self.collection_ma.set_segments(self.segment_ma[:, index_start:index_end])
+            self.collection_ma.set_edgecolor(self.edgecolor_ma)
         return
 
-    def _set_segments(self, index_start, index_end, simpler, set_ma):
-        indsub = index_end - index_start
-        if index_start < 0: index_start = 0
-        if index_end < 1: index_end = 1
 
-        index_end += 2
-        if indsub < self.limit_candle:
-            self._set_candle_segments(index_start, index_end)
-        elif indsub < self.limit_wick:
-            self._set_wick_segments(index_start, index_end, simpler)
-        else:
-            self._set_line_segments(index_start, index_end, simpler, set_ma)
-        return
+class VolumeSegmentMixin(MaSegmentMixin):
+    limit_volume = 200
 
-    def _set_candle_segments(self, index_start, index_end):
-        self.collection_candle.set_segments(self.segment_candle[index_start:index_end])
-        self.collection_candle.set_facecolor(self.facecolor_candle[index_start:index_end])
-        self.collection_candle.set_edgecolor(self.edgecolor_candle[index_start:index_end])
+    def _create_volume_segments(self):
+        # 거래량 바 세그먼트
+        segment_volume = self.df[[
+            'left_volume', 'zero',
+            'left_volume', self.volume,
+            'right_volume', self.volume,
+            'right_volume', 'zero',
+        ]].values
+        self.segment_volume = segment_volume.reshape(segment_volume.shape[0], 4, 2)
 
-        if self.volume:
-            self.collection_volume.set_segments(self.segment_volume[index_start:index_end])
-            self.collection_volume.set_linewidth(0.7)
-            self.collection_volume.set_facecolor(self.facecolor_volume[index_start:index_end])
-            self.collection_volume.set_edgecolor(self.edgecolor_volume[index_start:index_end])
+        # 거래량 심지 세그먼트
+        segment_volume_wick = self.df[[
+            'x', 'zero',
+            'x', self.volume,
+        ]].values
+        self.segment_volume_wick = segment_volume_wick.reshape(segment_volume_wick.shape[0], 2, 2)
 
-        self.collection_ma.set_segments(self.segment_ma[:, index_start:index_end])
-        self.collection_ma.set_edgecolor(self.edgecolor_ma)
+        self._create_volume_color_segments()
         return
 
-    def _set_wick_segments(self, index_start, index_end, simpler=False):
-        self.collection_candle.set_segments(self.segment_candle_wick[index_start:index_end])
-        self.collection_candle.set_facecolor([])
-        self.collection_candle.set_edgecolor(self.edgecolor_candle[index_start:index_end])
+    def _create_volume_color_segments(self):
+        if self.set_volumecolor:
+            columns = ['facecolor_volume', 'edgecolor_volume']
+            # 거래량
+            self.df.loc[:, columns] = (self.color_volume_up, self.color_volume_up)
+            if self.color_up != self.color_down:
+                # 전일대비 하락
+                condition = self.df[self.close] < self.df['close_pre']
+                self.df.loc[condition, columns] = (self.color_volume_down, self.color_volume_down)
+            if self.color_up != self.color_flat:
+                # 전일과 동일
+                condition = self.df[self.close] == self.df['close_pre']
+                self.df.loc[condition, columns] = (self.color_volume_flat, self.color_volume_flat)
 
-        if self.volume:
-            seg_volume = self.segment_volume_wick[index_start:index_end]
-            seg_facecolor_volume = self.facecolor_volume[index_start:index_end]
-            seg_edgecolor_volume = self.edgecolor_volume[index_start:index_end]
-            if simpler:
-                values = seg_volume[:, 1, 1]
-                top_index = np.argsort(-values)[:self.limit_volume]
-                seg_volume = seg_volume[top_index]
-                seg_facecolor_volume = seg_facecolor_volume[top_index]
-                seg_edgecolor_volume = seg_edgecolor_volume[top_index]
-            self.collection_volume.set_segments(seg_volume)
-            self.collection_volume.set_linewidth(1.3)
-            self.collection_volume.set_facecolor(seg_facecolor_volume)
-            self.collection_volume.set_edgecolor(seg_edgecolor_volume)
-
-        self.collection_ma.set_segments(self.segment_ma[:, index_start:index_end])
-        self.collection_ma.set_edgecolor(self.edgecolor_ma)
-        return
-
-    def _set_line_segments(self, index_start, index_end, simpler=False, set_ma=True):
-        self.collection_candle.set_segments(self.segment_priceline[:, index_start:index_end])
-        self.collection_candle.set_facecolor([])
-        self.collection_candle.set_edgecolor(self.color_priceline)
+        self.facecolor_volume = self.df['facecolor_volume'].values
+        self.edgecolor_volume = self.df['edgecolor_volume'].values
+        return
 
-        if self.volume:
-            seg_volume = self.segment_volume_wick[index_start:index_end]
-            seg_facecolor_volume = self.facecolor_volume[index_start:index_end]
-            seg_edgecolor_volume = self.edgecolor_volume[index_start:index_end]
-            if simpler:
-                values = seg_volume[:, 1, 1]
-                top_index = np.argsort(-values)[:self.limit_volume]
-                seg_volume = seg_volume[top_index]
-                seg_facecolor_volume = seg_facecolor_volume[top_index]
-                seg_edgecolor_volume = seg_edgecolor_volume[top_index]
-            self.collection_volume.set_segments(seg_volume)
-            self.collection_volume.set_linewidth(1.3)
-            self.collection_volume.set_facecolor(seg_facecolor_volume)
-            self.collection_volume.set_edgecolor(seg_edgecolor_volume)
+    def _set_volume_segments(self, index_start, index_end):
+        self.collection_volume.set_segments(self.segment_volume[index_start:index_end])
+        self.collection_volume.set_linewidth(0.7)
+        self.collection_volume.set_facecolor(self.facecolor_volume[index_start:index_end])
+        self.collection_volume.set_edgecolor(self.edgecolor_volume[index_start:index_end])
+        return
 
-        if not set_ma: self.collection_ma.set_segments([])
-        else:
-            self.collection_ma.set_segments(self.segment_ma[:, index_start:index_end])
-            self.collection_ma.set_edgecolor(self.edgecolor_ma)
+    def _set_volume_wick_segments(self, index_start, index_end, simpler):
+        seg_volume = self.segment_volume_wick[index_start:index_end]
+        seg_facecolor_volume = self.facecolor_volume[index_start:index_end]
+        seg_edgecolor_volume = self.edgecolor_volume[index_start:index_end]
+        if simpler:
+            values = seg_volume[:, 1, 1]
+            top_index = np.argsort(-values)[:self.limit_volume]
+            seg_volume = seg_volume[top_index]
+            seg_facecolor_volume = seg_facecolor_volume[top_index]
+            seg_edgecolor_volume = seg_edgecolor_volume[top_index]
+        self.collection_volume.set_segments(seg_volume)
+        self.collection_volume.set_linewidth(1.3)
+        self.collection_volume.set_facecolor(seg_facecolor_volume)
+        self.collection_volume.set_edgecolor(seg_edgecolor_volume)
         return
 
 
-class EventMixin(SegmentMixin):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+class SegmentMixin(VolumeSegmentMixin):
+    limit_wick = 4_000
 
-        self._connect_event()
+    def _create_segments(self):
+        self._create_candle_segments()
+        self._create_ma_segments()
+        if self.volume: self._create_volume_segments()
         return
 
+    def _set_collection_segments(self, index_start, index_end, indsub, simpler, set_ma=True):
+        if indsub < self.limit_candle:
+            self._set_candle_segments(index_start, index_end)
+            self._set_ma_segments(index_start, index_end, set_ma)
+            if self.volume: self._set_volume_segments(index_start, index_end)
+        elif indsub < self.limit_wick:
+            self._set_candle_wick_segments(index_start, index_end)
+            self._set_ma_segments(index_start, index_end, set_ma)
+            if self.volume: self._set_volume_wick_segments(index_start, index_end, simpler)
+        else:
+            self._set_priceline_segments(index_start, index_end)
+            self._set_ma_segments(index_start, index_end, set_ma)
+            if self.volume: self._set_volume_wick_segments(index_start, index_end, simpler)
+        return
+
+
+class EventMixin(SegmentMixin):
     def _connect_event(self):
+        super()._connect_event()
+
         self.figure.canvas.mpl_connect('pick_event', lambda x: self._on_pick(x))
         return
 
@@ -417,12 +462,9 @@ class EventMixin(SegmentMixin):
 
     def _pick_ma_action(self, e: PickEvent):
         handle = e.artist
-        if handle.get_alpha() == 0.2:
-            visible = True
-            handle.set_alpha(1.0)
-        else:
-            visible = False
-            handle.set_alpha(0.2)
+
+        visible = handle.get_alpha() == 0.2
+        handle.set_alpha(1.0 if visible else 0.2)
 
         n = int(handle.get_label())
         if visible: self._visible_ma = {i for i in self.list_ma if i in self._visible_ma or i == n}
@@ -431,68 +473,25 @@ class EventMixin(SegmentMixin):
         alphas = [(1 if i in self._visible_ma else 0) for i in reversed(self.list_ma)]
         self.collection_ma.set_alpha(alphas)
 
-        self._draw()
-        return
-
-    def _draw(self):
         self.figure.canvas.draw()
         return
 
 
-class DrawMixin(EventMixin):
+class LimMixin(EventMixin):
     candle_on_ma = True
 
     def set_data(self, df, sort_df=True, calc_ma=True, set_candlecolor=True, set_volumecolor=True, *args, **kwargs):
         self._generate_data(df, sort_df, calc_ma, set_candlecolor, set_volumecolor, *args, **kwargs)
-        self._get_segments()
+        self._create_segments()
 
         vmin, vmax = self.get_default_lim()
         self._set_lim(vmin, vmax)
         return
 
-    def _connect_event(self):
-        super()._connect_event()
-        self.figure.canvas.mpl_connect('draw_event', lambda x: self._on_draw(x))
-        return
-
-    def _on_draw(self, e):
-        self._draw_artist()
-        self._blit()
-        return
-
-    def _draw_artist(self):
-        renderer = self.figure.canvas.renderer
-
-        self.ax_price.xaxis.draw(renderer)
-        self.ax_price.yaxis.draw(renderer)
-
-        if self.candle_on_ma:
-            self.collection_ma.draw(renderer)
-            self.collection_candle.draw(renderer)
-        else:
-            self.collection_candle.draw(renderer)
-            self.collection_ma.draw(renderer)
-
-        if self.watermark:
-            self.text_watermark.set_text(self.watermark)
-            self.text_watermark.draw(renderer)
-
-        self.ax_volume.xaxis.draw(renderer)
-        self.ax_volume.yaxis.draw(renderer)
-
-        self.collection_volume.draw(renderer)
-        return
-
-    def _blit(self):
-        self.figure.canvas.blit()
-        return
-
     def _set_lim(self, xmin, xmax, simpler=False, set_ma=True):
-        self.vxmin, self.vxmax = (xmin, xmax + 1)
+        self.vxmin, self.vxmax = (xmin, xmax)
         if xmin < 0: xmin = 0
-        if xmax < 0: xmax = 0
-        xmax += 1
-        if xmin == xmax: xmax += 1
+        if xmax < 1: xmax = 1
 
         ymin, ymax = (self.df[self.low][xmin:xmax].min(), self.df[self.high][xmin:xmax].max())
         yspace = (ymax - ymin) / 15
@@ -502,8 +501,9 @@ class DrawMixin(EventMixin):
         # 거래량 차트 ymax
         self.volume_ymax = self.df['ymax_volume'][xmin:xmax].max() if self.volume else 1
 
-        self._set_segments(xmin, xmax, simpler, set_ma)
         self._change_lim(self.vxmin, self.vxmax)
+        xsub = xmax - xmin
+        self._set_collection_segments(xmin, xmax, xsub, simpler, set_ma)
         return
 
     def _change_lim(self, xmin, xmax):
@@ -519,19 +519,14 @@ class DrawMixin(EventMixin):
         return
 
     def get_default_lim(self):
-        return (0, self.list_index[-1])
+        return (0, self.list_index[-1]+1)
 
 
-class BackgroundMixin(DrawMixin):
+class BackgroundMixin(LimMixin):
     background = None
 
     _creating_background = False
 
-    def _connect_event(self):
-        self.figure.canvas.mpl_connect('pick_event', lambda x: self._on_pick(x))
-        self.figure.canvas.mpl_connect('draw_event', lambda x: self._on_draw(x))
-        return
-
     def _create_background(self):
         if self._creating_background: return
 
@@ -562,17 +557,13 @@ class BaseMixin(BackgroundMixin):
 
 
 class Chart(BaseMixin, Mixin):
-    def _add_collection(self):
-        super()._add_collection()
-        return self.add_artist()
-
     def _draw_artist(self):
         super()._draw_artist()
         return self.draw_artist()
 
-    def _get_segments(self):
-        self.generate_data()
-        return super()._get_segments()
+    def _set_lim(self, xmin, xmax, simpler=False, set_ma=True):
+        super()._set_lim(xmin, xmax, simpler, set_ma)
+        return self.on_change_xlim(xmin, xmax, simpler, set_ma)
 
     def _on_draw(self, e):
         super()._on_draw(e)
@@ -582,18 +573,3 @@ class Chart(BaseMixin, Mixin):
         self.on_pick(e)
         return super()._on_pick(e)
 
-    def _set_candle_segments(self, index_start, index_end):
-        super()._set_candle_segments(index_start, index_end)
-        self.set_segment(index_start, index_end)
-        return
-
-    def _set_wick_segments(self, index_start, index_end, simpler=False):
-        super()._set_wick_segments(index_start, index_end, simpler)
-        self.set_segment(index_start, index_end, simpler)
-        return
-
-    def _set_line_segments(self, index_start, index_end, simpler=False, set_ma=True):
-        super()._set_line_segments(index_start, index_end, simpler, set_ma)
-        self.set_segment(index_start, index_end, simpler, set_ma)
-        return
-