Calculate the ConstantPointCoordinates features for the case of
           a fixed number of strokes.

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