batoolset 0.1.0__py3-none-any.whl

batoolset/draw/shapes/Position.py

@@ -0,0 +1,183 @@
+# TODO make these things combined with pack and align commands and make loops
+# this way I can make any component at any specific position !!!
+# this is quite good I think
+import copy
+import traceback
+from itertools import groupby
+
+
+from batoolset.figure.alignment import packing_modes
+
+
+# Define a sorting key function to sort objects based on their positions
+def sorting_key(obj):
+    try:
+        return tuple(sorted(obj.items()))
+    except:
+        try:
+            return tuple(sorted(obj.placement.get_position()))
+        except:
+            # pass
+            return ('free','relative') # if the object does not have a position assume it obeys free/relative positioning
+
+def groupby_position(objects):
+    from batoolset.draw.shapes.txt2d import TAText2D
+    if isinstance(objects, TAText2D):
+        objects = [objects]
+    # Sort the objects based on their positions
+    sorted_objects = sorted(objects, key=sorting_key)
+    # Group the sorted objects based on their positions
+    grouped_objects = {key: list(group) for key, group in groupby(sorted_objects, key=sorting_key)}
+    return grouped_objects
+
+
+class Position:
+    positions = {
+        'top': False,
+        'bottom': False,
+        'left': False,
+        'right': False,
+        'center_h': False,
+        'center_v': False
+    }
+
+    def __init__(self, position=None):
+        self.positions = copy.deepcopy(Position.positions)
+        if position is not None:
+            self.set_position(position)
+
+    def set_position(self, position):
+        for key in self.positions.keys(): # reset all positions
+            self.positions[key] = False
+
+        if not position:
+            return
+
+        position = position.lower()
+        # except:
+        #     traceback.print_exc()
+        #     print('position', position)
+
+        if 'top' in position:
+            self.positions['top'] = True
+        if 'bottom' in position:
+            self.positions['bottom'] = True
+        if 'left' in position:
+            self.positions['left'] = True
+        if 'right' in position:
+            self.positions['right'] = True
+        if 'center_h' in position:
+            self.positions['center_h'] = True
+        if 'center_v' in position:
+            self.positions['center_v'] = True
+
+    def get_position(self):
+        return {key: value for key, value in self.positions.items() if value}
+
+    def check_position(self, position):
+        if not position in self.positions:
+            return False
+        return self.positions[position]
+
+    def position_to_string(self):
+        out = ''
+        if self.positions['top']:
+            out += 'top '
+        if self.positions['bottom']:
+            out += 'bottom '
+        if self.positions['left']:
+            out += 'left '
+        if self.positions['right']:
+            out += 'right '
+        if self.positions['center_h']:
+            out += 'center_h '
+        if self.positions['center_v']:
+            out += 'center_v '
+
+        return out.strip()
+
+    def get_packing_orientation(self):
+        # try rescue packing mode from position
+        # if reference.position.get_position():
+        if self.check_position('top'):
+            return packing_modes[1]
+        elif self.check_position('bottom'):
+            return packing_modes[3]
+        # elif mode.check_position('left'):
+        #     mode = packing_modes[0]
+        # elif mode.check_position('right'):
+        #     mode = packing_modes[2]
+        # else:
+        #     # logger.error('unknown positioning --> ignoring')
+        #     print('unknown position ignoring')
+
+    def isEmpty(self):
+        for key, value in self.positions.items():
+            if value:
+                return False
+        return True
+
+    def __str__(self):
+        return self.position_to_string()
+
+# very good --> maybe just slightly improve it and fix it --> it will be placed with repsect to the parent stuff
+if __name__ == '__main__':
+    # Create a new Position object
+    p = Position()
+    print(p.get_position()) # --> empty
+
+    # Set the position
+    p.set_position('top left')
+    # Get the current position
+    print(p.get_position())  # Output: {'top': True, 'left': True}
+
+    p.set_position('TOp Left')
+    # Get the current position
+    print(p.get_position())  # Output: {'top': True, 'left': True}
+
+    p.set_position('Bottom Right')
+    # Get the current position
+    print(p.get_position())  # Output: {'top': True, 'left': True}
+
+
+    print('pos to string', p.position_to_string())
+
+    print(p.check_position('top'))
+    print(p.check_position('right'))
+    print(p.check_position('bottom'))
+
+    p2 = Position()
+
+
+
+    print(p2.get_position())
+
+    print(p2.isEmpty())
+    print(p.isEmpty())
+
+
+
+    if False:
+
+        # List of objects with positions
+        objects = [
+            {'top': True, 'left': True},
+            {'bottom': True, 'right': True},
+            {'top': True, 'left': True},
+            {'bottom': True, 'left': True}
+        ]
+
+        grouped_objects = groupby_position(objects)
+
+
+
+
+        print(grouped_objects)
+
+        # Print the grouped objects
+        for position, objects_in_group in grouped_objects.items():
+            print(f"Position: {position}")
+            for obj in objects_in_group:
+                print(obj)
+            print()
+

batoolset/draw/shapes/automated_alignment_drawing_refactored.py

@@ -0,0 +1,346 @@
+from batoolset.settings.global_settings import set_UI # set the UI to qtpy
+set_UI()
+import random
+import sys
+from qtpy.QtGui import QTransform,QPolygon
+from qtpy.QtWidgets import QApplication, QWidget
+from qtpy.QtGui import QPainter, QPen, QBrush, QColor
+from qtpy.QtCore import Qt, QPointF, QRectF,QPoint
+from batoolset.draw.shapes.polyline2d import PolyLine2D
+from batoolset.draw.shapes.transform2D import get_centroid, get_points, Transform2D
+
+def compute_translation_corrections(img1, minimal_return=True):
+    old_scale = img1.scale
+    img1.set_to_scale(1.)
+
+    parent_rect = QRectF(img1.getRect(raw=True))
+    parent_rect = QRectF(0, 0, parent_rect.width(), parent_rect.height())
+
+    theta = img1.theta
+    if not theta:
+        theta=0
+    crop_left = img1.crop_left
+    crop_right = img1.crop_right
+    crop_top = img1.crop_top
+    crop_bottom = img1.crop_bottom
+    if not crop_left:
+        crop_left=0
+    if not crop_right:
+        crop_right=0
+    if not crop_top:
+        crop_top=0
+    if not crop_bottom:
+        crop_bottom=0
+
+    center_parent = parent_rect.center()
+    transform = QTransform()
+    transform.translate(-center_parent.x(), -center_parent.y())
+    transform.rotate(theta)
+    transform.translate(center_parent.x(), center_parent.y())
+    rotated_rect = transform.mapToPolygon(parent_rect.toRect())  # this is the center versio n
+    rotated_rect_bounds = transform.mapRect(parent_rect)
+    trans = parent_rect.center() - rotated_rect_bounds.center()  # this is the center version
+    rotated_rect_bounds.translate(trans)
+    rotated_rect_before_trans = QPolygon(rotated_rect)
+    rotated_rect.translate(int(trans.x()), int(trans.y()))  # --> error --> this stuff is not at the right place
+    crop_rect = QRectF(rotated_rect_bounds.x() + crop_left, rotated_rect_bounds.y() + crop_top,
+                            rotated_rect_bounds.width() - crop_right - crop_left,
+                            rotated_rect_bounds.height() - crop_top - crop_bottom)
+    rect = crop_rect
+    centroid_of_crop = get_centroid(get_points(rect))
+
+    center_before_reg = get_centroid(get_points(rotated_rect_before_trans))
+    rotated_rect_before_trans.translate(-int(center_before_reg[0] - centroid_of_crop[0]),
+                                             -int(center_before_reg[1] - centroid_of_crop[1]))
+
+    fixing_error_trans = img1.getRect(all=True).center() - crop_rect.center()
+    extra_fix = QPointF(
+        rotated_rect_before_trans.boundingRect().center() - rotated_rect.boundingRect().center())  # now it is perfectly aligned to the light cyan rect -−> how cna I realign it now to the cyan rect
+    fixing_error_trans += extra_fix
+    extra_user_translation = (fixing_error_trans.x(), fixing_error_trans.y())
+
+    img1.set_to_scale(old_scale)
+
+    # bug fix if image is not at 0,0, remove extra useless translation
+    extra_user_translation = (extra_user_translation[0]-img1.x(), extra_user_translation[1]-img1.y())
+
+    if minimal_return:
+        return extra_user_translation,rotated_rect.boundingRect().center() - rotated_rect_before_trans.boundingRect().center()
+    else:
+        return centroid_of_crop,center_parent, rotated_rect_before_trans, crop_rect, parent_rect, rotated_rect_bounds, rotated_rect, extra_user_translation,rotated_rect.boundingRect().center()-rotated_rect_before_trans.boundingRect().center()
+#
+# class AutomaticDrawingOfRegistrationRect(QWidget):
+#     def __init__(self):
+#         super().__init__()
+#
+#         self.MODE_CHECK = True # I fTrue uses the default mode
+#
+#         self.theta = random.randint(-359, 359)
+#         self.theta = 42
+#         self.theta = 0
+#
+#         lines = [
+#             (0, 0, 0, 0),
+#             (30, 40, 60, 80),
+#             (90, 10, 33, 16),
+#             (60, 30, 0, 0), # this one seems buggy
+#             (60, 0, 0, 0),
+#             (90, 0, 0, 0),
+#             (0, 60, 0, 0),
+#             (0, 90, 0, 0),
+#             (60, 60, 0, 0),
+#             (60, 60, 40, 40),
+#             (0, 0, 40, 40),
+#             (0, 0, 0, 40),
+#             (0, 0, 0, 90),
+#             (0, 0, 40, 0),
+#             (0, 0, 90, 0),
+#             (60, 0, 40, 0),
+#             (60, 0, 0, 40),
+#             (0, 60, 0, 40),
+#             (0, 60, 40, 0),
+#             (0, 60, 40, 30),
+#             (60, 0, 40, 30),
+#             (60, 40, 0, 30),
+#             (60, 40, 50, 0),
+#             (30, 70, 10, 0)
+#         ]
+#
+#         # Randomly select a line and execute it
+#         self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = random.choice(lines)
+#
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 0, 0, 0
+#         self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 30, 40, 60, 80
+#         self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 60, 30, 0, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 90, 10, 33, 16
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 60, 0, 0, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 90, 0, 0, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 60, 0, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 90, 0, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 60, 60, 0, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 60, 60, 40, 40
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 0, 40, 40
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 0, 0, 40
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 0, 0, 90
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 0, 40, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 0, 90, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 60, 0, 40, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 60, 0, 0, 40
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 60, 0, 40
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 60, 40, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 0, 60, 40, 30
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 60, 0, 40, 30
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 60, 40, 0, 30
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 60, 40, 50, 0
+#         # self.crop_left, self.crop_right, self.crop_top, self.crop_bottom = 30, 70, 10, 0
+#
+#         from pyfigures.gui.keep_tst_images_for_pzf import get_complex_tst_image
+#         img1 = get_complex_tst_image()
+#         img1.set_rotation(self.theta)
+#         img1.crop(self.crop_left, self.crop_right, self.crop_top, self.crop_bottom)
+#         # img1.set_to_scale(1) # make sure it is full size
+#         self.img = img1
+#
+#         # if there is scaling --> there is an error --> try to see why that is
+#         # self.img.set_to_scale(1./0.3)
+#
+#         print(self.img.scale)
+#         self.img.scale=1 # apparently the bug is there
+#         # self.img.scale=1/0.3 # apparently the bug is there # ok --> now scale is finally supported --> very good
+#         # self.img.scale=2
+#
+#         # test of all
+#
+#         self.centroid_of_crop, self.center_parent, self.rotated_rect_before_trans, self.crop_rect, self.parent_rect, self.rotated_rect_bounds, self.rotated_rect, extra_user_translation, self.extra_translation_at_painter = compute_translation_corrections(img1, minimal_return=False)
+#
+#         if not self.MODE_CHECK:
+#             self.img.extra_user_translation = extra_user_translation
+#         else:
+#             self.img.extra_user_translation = (0,0)
+#
+#         self.rect = self.crop_rect
+#
+#         print('extra_user_translation', extra_user_translation)
+#         print('extra_translation_at_painter', self.extra_translation_at_painter)
+#         # print('fixing_error_trans', self.fixing_error_trans)
+#
+#         self.line_length = 10  # pixels
+#         self.colors = [QColor(Qt.red), QColor(Qt.green), QColor(Qt.blue), QColor(Qt.yellow)]
+#
+#         self.center_after_reg = get_centroid(get_points(self.rotated_rect_before_trans))
+#
+#         points_of_unrotated_rect = get_points(self.rect)
+#         trafo2D = Transform2D()
+#         trafo2D.translate(self.center_parent.x(), self.center_parent.y())
+#         trafo2D.rotate(-self.theta)
+#         trafo2D.translate(-self.center_parent.x(), -self.center_parent.y())
+#
+#         # this will give me the rect to plot on the parent -−> quite easy
+#         rotated_back_points = trafo2D.apply(points_of_unrotated_rect)
+#         self.fixed_center = get_centroid(rotated_back_points)
+#
+#         self.setMinimumSize(800,600)
+#         self.update()
+#
+#
+#     def draw_alignment_rect(self, painter):
+#         painter.setPen(QColor(0, 0, 0))
+#
+#         # Draw the crop values as text
+#         painter.drawText(10, 20, f"Crop Left: {self.crop_left}")
+#         painter.drawText(10, 40, f"Crop Right: {self.crop_right}")
+#         painter.drawText(10, 60, f"Crop Top: {self.crop_top}")
+#         painter.drawText(10, 80, f"Crop Bottom: {self.crop_bottom}")
+#         painter.drawText(10, 100, f"Angle: {self.theta }")
+#
+#         painter.translate(256, 256) # just to better visualize and understand all !! -> TODO
+#
+#         if True:
+#             random_number = random.uniform(0.1, 3.0)
+#             painter.scale(random_number,random_number) # ça marche et c'est scale insensitive --> TODO à fixer
+#
+#
+#
+#         if True:
+#             painter.save()
+#             # if not (self.crop_left and self.crop_right and self.crop_top and self.crop_bottom):
+#             # if False:
+#             if True:
+#                 painter.translate((self.crop_rect.center() - self.img.getRect(all=True).center())/self.img.scale) # very good -> this is sufficient to align the center to that
+#                 # this is just to center the image this stuff is in fact largely usless!!!
+#
+#                 # pass
+#             # painter.translate(self.center_after_reg[0]- self.img.getRect(all=True).center().x(),self.center_after_reg[1]- self.img.getRect(all=True).center().y()) # very good -> this is sufficient to align the center to that
+#             # painter.translate(self.center_after_reg[0]- self.img.getRect(all=True).center().x(),self.center_after_reg[1]- self.img.getRect(all=True).center().y()) # very good -> this is sufficient to align the center to that
+#             # painter.translate(self.rotated_rect.boundingRect().center().x()-self.img.getRect(all=True).center().x(),self.rotated_rect.boundingRect().center().y()-self.img.getRect(all=True).center().y()) # very good -> this is sufficient to align the center to that
+#             # rotated center centered on that
+#             self.img.draw_bg(painter, restore_painter_in_the_end=True)
+#
+#             # this is the really important stuff and again it should be scaled
+#             # painter.translate(self.rotated_rect.boundingRect().center()-self.rotated_rect_before_trans.boundingRect().center()) # ça marche is je met le truc ici --> par contre est ce que je controle la position ???
+#             if not self.MODE_CHECK:
+#             # if True:
+#                 painter.translate(self.extra_translation_at_painter/self.img.scale)  # ça marche is je met le truc ici --> par contre est ce que je controle la position ???
+#
+#             self.img.draw_annotations(painter, restore_painter_in_the_end=False)
+#             painter.restore()
+#
+#         # Reset the clipping region
+#         # painter.setClipping(False)
+#
+#         shapes_drawn = []
+#
+#         pen = QPen(Qt.lightGray, 6)
+#         painter.setPen(pen)
+#         # Draw the rectangle
+#         painter.drawRect(self.parent_rect)
+#         pen.setWidthF(24)
+#         painter.setPen(pen)
+#         painter.drawPoint(self.parent_rect.center())  # ok
+#
+#         pen = QPen(Qt.yellow, 6)
+#         painter.setPen(pen)
+#         # Draw the rectangle
+#         painter.drawRect(self.rotated_rect_bounds)
+#         pen.setWidthF(12)
+#         painter.setPen(pen)
+#         painter.drawPoint(self.rotated_rect_bounds.center())  # ok
+#
+#         pen = QPen(Qt.cyan,6)
+#         painter.setPen(pen)
+#         painter.drawPolygon(self.rotated_rect)
+#         painter.drawPoint(self.rotated_rect.boundingRect().center())
+#
+#         # pen = QPen(QColor(224, 128, 255), 6)  # lighcyan
+#         pen = QPen(QColor(255, 0, 0), 1)  # lighcyan
+#         painter.setPen(pen)
+#         painter.drawPolygon(self.rotated_rect_before_trans)
+#         pen.setWidthF(12)
+#         painter.setPen(pen)
+#         painter.drawPoint(
+#             self.rotated_rect_before_trans.boundingRect().center())  # this is aligned with the the centroid of crop probably by construction
+#
+#         # painter.save()
+#         # painter.translate(-center_parent.x(), -center_parent.y())
+#         # painter.rotate(self.theta)
+#         # painter.translate(center_parent.x(), center_parent.y())
+#
+#         pen = QPen(Qt.darkGray, 6)
+#         painter.setPen(pen)
+#         # Draw the rectangle
+#         painter.drawRect(self.rect)
+#         painter.drawPoint(int(self.centroid_of_crop[0]), int(self.centroid_of_crop[1]))  # ok
+#
+#         # maybe get the center of the rotated back shit
+#
+#         if True:
+#             # this belongs to the unrotated rect that I never plotted
+#             pen = QPen(Qt.red, 3)
+#             painter.setPen(pen)
+#             painter.drawPoint(int(self.fixed_center[0]),int(self.fixed_center[1]))  # ok
+#
+#         # now put the extra correction
+#         # maybe it is one of these centroids that I should use
+#
+#         # painter.restore()
+#
+#         # Draw two orthogonal lines at each corner with unique colors
+#         corners = [self.rect.topLeft(), self.rect.topRight(), self.rect.bottomLeft(), self.rect.bottomRight()]
+#         for i, point in enumerate(corners):
+#             x, y = point.x(), point.y()
+#             sign_x, sign_y = 1, 1
+#             if i in [1, 3]:
+#                 sign_x = -1
+#             if i in [2, 3]:
+#                 sign_y = -1
+#             painter.setPen(QPen(self.colors[i], 2))
+#             painter.drawLine(point, QPointF(x + self.line_length * sign_x, y))
+#             painter.drawLine(point, QPointF(x, y + self.line_length * sign_y))
+#             # test = PolyLine2D(*[x + self.line_length * sign_x, x,y, x,y,  x , y + self.line_length * sign_y])
+#             corner = PolyLine2D(x + self.line_length * sign_x, y, x, y, x, y, x, y + self.line_length * sign_y, stroke=1,
+#                               color=self.colors[i].toRgb())
+#             # corner.draw(painter)
+#             shapes_drawn.append(corner)
+#
+#             # print(test.count())
+#
+#         # Draw a cross at the center
+#         center = self.rect.center()
+#         pen = QPen(QColor(Qt.magenta), 2)
+#         painter.setPen(pen)
+#         painter.drawLine(QPointF(center.x() - self.line_length, center.y()),
+#                          QPointF(center.x() + self.line_length, center.y()))
+#         painter.drawLine(QPointF(center.x(), center.y() - self.line_length),
+#                          QPointF(center.x(), center.y() + self.line_length))
+#         horiz = PolyLine2D(center.x() - self.line_length, center.y(), center.x() + self.line_length, center.y(),
+#                            stroke=1,
+#                            color=QColor(Qt.magenta).toRgb())
+#         vert = PolyLine2D(center.x(), center.y() - self.line_length, center.x(), center.y() + self.line_length,
+#                           stroke=1,
+#                           color=QColor(Qt.magenta).toRgb())
+#         # horiz.draw(painter)
+#         # vert.draw(painter)
+#         shapes_drawn.append(horiz)
+#         shapes_drawn.append(vert)
+#         return shapes_drawn
+#
+#     def paintEvent(self, event):
+#         painter = QPainter(self)
+#
+#         shapes_drawn = self.draw_alignment_rect(painter)
+#
+#         # Now I could try to really map these shapes on the real image!!!
+#
+#         # print(shapes_drawn)
+#         painter.end()
+#         # the shapes and te lines are now ok --> I can then use them to register the fake image and compute the messed up translation --> TODO
+#
+#         # convert this also to a polyline line object so that I can draw it!!!
+#         # see how I can do that
+#
+# if __name__ == '__main__':
+#     app = QApplication(sys.argv)
+#     widget = AutomaticDrawingOfRegistrationRect()
+#     widget.resize(640, 480)
+#     widget.show()
+#     sys.exit(app.exec_())

batoolset/draw/shapes/circle2d.py

@@ -0,0 +1,99 @@
+from batoolset.draw.shapes.ellipse2d import *
+from batoolset.tools.logger import TA_logger
+
+logger = TA_logger()
+
+
+class Circle2D(Ellipse2D):
+
+    def __init__(self, *args,x=0, y=0, width=0, color=0xFFFFFF, fill_color=None, opacity=1., stroke=0.65,line_style=None, __version__=1.0, **kwargs):
+        # print('args here',args)
+        if len(args) == 3:
+            super(Circle2D, self).__init__(*args, args[-1])
+        elif len(args) == 4:
+            logger.error("too many values, cirle only has, x,y and width")
+        else:
+            if args:
+                super(Circle2D, self).__init__(*args)  # create empty circle
+            else:
+                super(Circle2D, self).__init__(x,y,width, width)  # create empty circle
+        self.setRect(self.rect())
+        self.color = color
+        self.fill_color = fill_color
+        self.stroke = stroke
+        self.opacity = opacity
+        self.line_style = line_style
+        self.__version__ = __version__
+        # rotation
+        # self.theta = theta
+
+    def add(self, *args): # this is required for drawing a cicrle otherwise it becomes as ellipse...
+        p1 = args[0]
+        p2 = args[1]
+
+        rect = self.rect()
+
+        x = p2.x()
+        y = p2.y()
+        x2 = p1.x()
+        y2 = p1.y()
+        if p1.x() < p2.x():
+            x = p1.x()
+            x2 = p2.x()
+        if p1.y() < p2.y():
+            y = p1.y()
+            y2 = p2.y()
+        w = abs(x - x2)
+        h = abs(y - y2)
+        if w < h:
+            rect.setWidth(h)
+            rect.setHeight(h)
+        else:
+            rect.setWidth(w)
+            rect.setHeight(w)
+
+        rect.setX(x)
+        rect.setY(y)
+
+        self.setRect(rect)
+        self.isSet = True
+
+
+if __name__ == '__main__':
+    test = Circle2D(0, 0, 100)
+    # print(test.x(), test.y(), test.width(), test.height())
+    print(test.contains(QPointF(50, 50)))
+    print(test.contains(QPointF(15, 15)))
+    print(test.contains(QPointF(-1, -1)))
+    print(test.contains(QPointF(0, 0)))
+    print(test.contains(QPointF(100, 100)))
+    print(test.contains(QPointF(100, 100.1)))
+    print(test.x())
+    print(test.y())
+    print(test.translate(QPoint(10, 10)))
+    print(test.x())
+    print(test.y())
+
+    # p1 = test.p1()
+    # print(p1.x(), p1.y())
+    # p2 = test.p2()
+    # print(p2.x(), p2.y())
+    # print(test.arrow)
+    # print(test.length()) # sqrt 2 --> 141
+    # # if it's an arrow I can add easily all the stuff I need
+    #
+    # test = Rect2D(0, 0, 1, 1)
+    # p1 = test.p1()
+    # print(p1.x(), p1.y())
+    # p2 = test.p2()
+    # print(p2.x(), p2.y())
+    # print(test.arrow)
+    # import math
+    # print(test.length() == math.sqrt(2))  # sqrt 2
+    #
+    # test2 = Rect2D()
+    # p1 = test2.p1()
+    # print(p1.x(), p1.y())
+    # p2 = test2.p2()
+    # print(p2.x(), p2.y())
+    # print(test2.arrow)