docs: def _features_with_strokes(self, hwr_obj):
          """Calculate the ConstantPointCoordinates features for the case of
             a fixed number of strokes."""
          x = []
          img = Image.new('L', ((int(hwr_obj.get_width()*self.scaling_factor) + 2), (int(hwr_obj.get_height()*self.scaling_factor) + 2)), 'black')
          draw = ImageDraw.Draw(img, 'L')
          pointlist = hwr_obj.get_pointlist()
          bb = hwr_obj.get_bounding_box()
          for stroke_nr in range(self.strokes):
              last_point = None
              # make sure that the current symbol actually has that many
              # strokes
              if stroke_nr < len(pointlist):
                  for point_nr in range(self.points_per_stroke):
                      if point_nr < len(pointlist[stroke_nr]):
                          point = pointlist[stroke_nr][point_nr]
                          x.append(pointlist[stroke_nr][point_nr]['x'])
                          x.append(pointlist[stroke_nr][point_nr]['y'])
                          if last_point is None:
                              last_point = point
                          y_from = int((-bb['miny'] + last_point['y'])*self.scaling_factor)
                          x_from = int((-bb['minx'] + last_point['x'])*self.scaling_factor)
                          y_to = int((-bb['miny'] + point['y'])*self.scaling_factor)
                          x_to = int((-bb['minx'] + point['x'])*self.scaling_factor)
                          draw.line([x_from, y_from, x_to, y_to], fill='#ffffff', width=1)
                          if self.pixel_env > 0:
                              pix = img.load()
                              for x_offset in range(-self.pixel_env,
                                                    self.pixel_env + 1):
                                  for y_offset in range(-self.pixel_env,
                                                        self.pixel_env + 1):
                                      xp = int((-bb['minx'] + point['x'])
                                               * self.scaling_factor) + x_offset
                                      yp = int((-bb['miny'] + point['y'])
                                               * self.scaling_factor) + y_offset
                                      xp = max(0, xp)
                                      yp = max(0, yp)
                                      x.append(pix[xp, yp])
                          last_point = point
                      else:
                          x.append(self.fill_empty_with)
                          x.append(self.fill_empty_with)
                          if self.pixel_env > 0:
                              for i in range((1 + 2 * self.pixel_env)**2):
                                  x.append(self.fill_empty_with)
              else:
                  for _ in range(self.points_per_stroke):
                      x.append(self.fill_empty_with)
                      x.append(self.fill_empty_with)
                      if self.pixel_env > 0:
                          for i in range((1 + 2 * self.pixel_env)**2):
                              x.append(self.fill_empty_with)
          del draw
          return x