batoolset 0.1.0__py3-none-any.whl

batoolset/draw/widgets/col.py

@@ -0,0 +1,343 @@
+#https://docs.python.org/2/library/operator.html
+
+import os
+from batoolset.settings.global_settings import set_UI # set the UI to qtpy
+set_UI()
+from batoolset.draw.shapes.rect2d import Rect2D
+from qtpy.QtCore import QPointF, QRectF
+# logger
+from batoolset.tools.logger import TA_logger
+from batoolset.figure.row import Row  # KEEP Really required to avoid circular imports
+logger = TA_logger()
+
+
+# TODO hack it that it can handle rows or images if needed
+
+class col(Rect2D):
+
+    def __init__(self, *args, space=3, width=None):
+        self.images = []
+        self.widthInPixel = width
+        self.space = space
+        for arg in args:
+        #     if isinstance(arg, Column):
+        #         arg.packX(space=space)
+        #         arg.setToWidth(self.widthInPixel)
+            self.images.append(arg)
+            # else:
+            #     self.images.append(Column(arg, space=space, width=width))
+        super(Rect2D, self).__init__()
+        self.packY(space=space)
+
+    def __or__(self, other):
+        if isinstance(other, col):
+            pos = self.get_P1()
+            other_pos = other.get_P1()
+            self.set_P1(other_pos)
+            other.set_P1(pos)
+        else:
+            logger.error('swapping not implemented yet for ' + str(type(other)))
+
+    def __sub__(self, other):
+        if other in self.images:
+            self.images.remove(other)
+            return
+        for row in self.images:
+            row -= other
+        for row in reversed(self.images):
+            if row.isEmpty():
+                self.images.remove(row)
+
+        return self
+
+    def __add__(self, other):
+        from batoolset.figure.row import Row  # KEEP Really required to avoid circular imports # TODO is that still true ?
+        if isinstance(other, Row):
+            other.packX(space=self.space)
+            other.setToWidth(self.widthInPixel)
+            self.images.append(other)
+            return self
+        self.images.append(Row(other, space=self.space, width=self.widthInPixel))
+        self.packY(space=self.space)
+        return self
+
+    def __len__(self):
+        if self.images is None:
+            return 0
+        return len(self.images)
+
+    def __iter__(self):
+        ''' Returns the Iterator object '''
+        self._index = -1
+        return self
+
+    def __next__(self):
+        ''' Returns the next row of the col '''
+        self._index += 1
+        if self._index < len(self.images):
+            return self.images[self._index]
+        # End of Iteration
+        raise StopIteration
+
+    def setWidthInPixel(self, widthInPixel):
+        self.widthInPixel = widthInPixel
+        self.packY()
+
+     # Forces the block to be of width (width_in_px)
+    def setToWidth(self, width_in_px):
+        for image in self:
+            image.setToHeight(width_in_px)
+        self.packY(space=self.space)
+
+    def setToHeight(self, height_in_px):
+        for image in self:
+            image.setToHeight(height_in_px)
+        self.packY(space=self.space)
+
+    def getIncompressibleWidth(self):
+        extra_space = 0;
+        return extra_space;
+
+    def packX(self, space=3):
+        # pack shapes in x
+
+        last_x = 0
+        last_y = 0
+
+        for i in range(len(self.images)):
+            row = self.images[i]
+            if i != 0:
+                last_x += space
+            row.set_P1(last_x, row.get_P1().y())
+            # get all the bounding boxes and pack them with desired space in between
+            # get first point and last point in x
+            x = row.boundingRect().x()
+            y = row.boundingRect().y()
+            last_x = row.boundingRect().x() + row.boundingRect().width()
+            last_y = row.boundingRect().y() + row.boundingRect().height()
+        self.updateBoudingRect()
+
+
+    def packY(self, space=3):
+
+        if space is None:
+            space = 0
+
+        last_x = 0
+        last_y = 0
+
+
+        for i in range(len(self.images)):
+            row = self.images[i]
+            if i != 0:
+                last_y += space
+            row.set_P1(row.get_P1().x(), last_y)
+
+            x = row.boundingRect().x()
+            y = row.boundingRect().y()
+            last_x = row.boundingRect().x() + row.boundingRect().width()
+            last_y = row.boundingRect().y() + row.boundingRect().height()
+        self.updateBoudingRect()
+
+    def updateBoudingRect(self):
+        '''updates the image bounding rect depending on content
+
+        '''
+        x = None
+        y = None
+        x2 = None
+        y2 = None
+        for row in self:
+            topLeft = row.get_P1()
+            if x is None:
+                x = topLeft.x()
+            if y is None:
+                y = topLeft.y()
+            x = min(topLeft.x(), x)
+            y = min(topLeft.y(), y)
+            if x2 is None:
+                x2 = topLeft.x() + row.boundingRect().width()
+            if y2 is None:
+                y2 = topLeft.y() + row.boundingRect().height()
+            x2 = max(topLeft.x() + row.boundingRect().width(), x2)
+            y2 = max(topLeft.y() + row.boundingRect().height(), y2)
+
+        if x is not None:
+            self.setX(x)
+        if y is not None:
+            self.setY(y)
+        if x2 is not None:
+            self.setWidth(x2 - x)
+        if y2 is not None:
+            self.setHeight(y2 - y)
+
+    def set_P1(self, *args):
+        curP1 = self.get_P1()
+        Rect2D.set_P1(self, *args)
+        newP1 = self.get_P1()
+        # need do a translation of all its content images
+        for row in self:
+            row.translate(newP1.x() - curP1.x(), newP1.y() - curP1.y())
+
+    def translate(self, *args):
+        if len(args)==1:
+            point = args[0]
+            QRectF.translate(self, point.x(), point.y())
+            for img in self:
+                img.translate(point.x(), point.y())
+        else:
+            QRectF.translate(self, args[0], args[1])
+            for img in self:
+                img.translate(QPointF(args[0], args[1]))
+
+
+    def draw(self, painter, draw=True):
+        if draw:
+            painter.save()
+        if draw:
+            counter = 0
+            for row in self:
+                print('drawing', counter, row.boundingRect())
+                counter+=1
+                row.draw(painter, draw=draw)
+            painter.restore()
+
+    def fill(self, painter, draw=True):
+        if self.fill_color is None:
+            return
+        if draw:
+            painter.save()
+        if draw:
+            for row in self:
+                row.fill(painter, draw=draw)
+            painter.restore()
+
+        # TODO pb will draw the shape twice.... ---> because painter drawpolygon is called twice
+
+    def drawAndFill(self, painter):
+        painter.save()
+        self.draw(painter, draw=True)
+        painter.restore()
+
+if __name__ == '__main__':
+    from batoolset.draw.shapes.image2d import Image2D  # KEEP Really required to avoid circular imports
+
+    img1 = Image2D('/E/Sample_images/counter/00.png')
+    img2 = Image2D('/E/Sample_images/counter/01.png')
+    img3 = Image2D('/E/Sample_images/counter/02.png')
+    img4 = Image2D('/E/Sample_images/counter/03.png')
+    img5 = Image2D('/E/Sample_images/counter/04.png')
+    img6 = Image2D('/E/Sample_images/counter/05.png')
+    img8 = Image2D('/E/Sample_images/counter/06.png')
+    img9 = Image2D('/E/Sample_images/counter/07.png')
+    img10 = Image2D('/E/Sample_images/counter/08.png')
+    img11 = Image2D('/E/Sample_images/counter/09.png')
+
+    result = img1 | img2 # fix so that this works ???
+
+
+    print(result)
+    print(len(result.images))
+
+    #    result += img3
+    #    result += img4
+
+    #    print(result)
+    #    print(len(result.images)) # ça ça marche
+
+    #    if True:
+    #        sys.exit(0)
+
+    # img3.pop()
+
+    row2 = img3 | img4 | img8
+    # row2 = row(img3, img4)
+
+    print(row2)
+    print(row2.images)  # why 4 images here ....
+    print('row2', len(row2.images))  # pas bon trop d'images --> pkoi ????
+
+    print(Image2D)
+
+    fig = result + row2
+    print(fig)
+    print(len(fig.images))
+
+    count = 0
+    for img in fig.images:
+        print(count, img.filename)
+        count += 1
+
+    final_result = fig - img4
+    print(final_result)
+    print(final_result.images)
+    print(len(final_result.images))
+
+    # ça marche
+
+    final_result = img4 + fig  # ça ne marche pas
+    print(final_result)
+    print(final_result.images)
+    print(len(final_result.images))
+
+    # si je divide une row alors ça ajoute une colonne à la figure --> return 2 rows in a figure
+
+
+
+    fig = img5 / img6
+
+    print(fig)
+    print(fig.rows)
+    print(len(fig.rows))
+
+    final_fig = fig - img5
+
+    print(final_fig)
+    print(final_fig.rows)
+    print(len(final_fig.rows))
+
+    final_fig += row2
+
+    print(final_fig)
+    print(final_fig.rows)
+    print(len(final_fig.rows))
+
+    fig = (img9) / (img10 + img11)
+    print(fig)
+    print(fig.rows)
+    print(len(fig.rows))
+    print('r1', len(fig.rows[0].images))
+    print('r2', len(fig.rows[1].images))
+
+    # try the pack and check it
+    # almost there now in fact...
+
+    for img in row2:
+        print(img.boundingRect())
+
+    print(row2)
+    row2.packX()
+    for img in row2:
+        print(img.boundingRect())
+
+    row2.packY()
+    for img in row2:
+        print(img.boundingRect())
+
+    # ça marche
+
+    # tester le draw sur une image --> balancer un qimage ???
+
+
+
+    # print('#'*20)
+    # from qtpy.QtCore import QRectF, QPointF
+    # test = QRectF(0,0,411,512)
+    # print(test)
+    # test.setX(414) # --> fucks width --> need reput it in correct position
+    # # test.setWidth(411)
+    # print(test)
+    # test = QRectF(0,0,411,512)
+    # print(test)
+    # test.setTopLeft(QPointF(414,0))
+    # print(test)

batoolset/draw/widgets/image_group.py

@@ -0,0 +1,248 @@
+import os
+from batoolset.settings.global_settings import set_UI # set the UI to qtpy
+set_UI()
+from batoolset.draw.shapes.rect2d import Rect2D
+from qtpy.QtCore import QPointF, QRectF
+from deprecated import deprecated
+# logger
+from batoolset.tools.logger import TA_logger
+
+logger = TA_logger()
+
+
+# en fait le pack vaudrait mieux le faire là ça serait bcp plus utile
+# keep this in mind: https://stackoverflow.com/questions/34827132/changing-the-order-of-operation-for-add-mul-etc-methods-in-a-custom-c
+@deprecated(reason="will be removed soon")
+class group(Rect2D):
+
+    def __init__(self, *args, space=3):
+        self.images = []
+        for img in args:
+            #     if isinstance(img, Column):
+            #         self.images += img.images
+            #     else:
+            self.images.append(img)
+        # init super empty
+        super(Rect2D, self).__init__()
+        # self.isSet = True # required to allow dragging
+        self.space = space
+
+        # self.sameHeight(space=space)
+        # self.widthInPixel = width
+        # self.setToWidth(width)
+        self.updateBoudingRect()
+
+    def updateBoudingRect(self):
+        '''updates the image bounding rect depending on content'''
+        x = None
+        y = None
+        x2 = None
+        y2 = None
+        for img in self:
+            topLeft = img.get_P1()
+            if x is None:
+                x = topLeft.x()
+            if y is None:
+                y = topLeft.y()
+            x = min(topLeft.x(), x)
+            y = min(topLeft.y(), y)
+
+            # print(img, img.boundingRect(), type(img))
+            # print(img, img.boundingRect(), type(img), img.boundingRect().height())
+
+            if x2 is None:
+                x2 = topLeft.x() + img.boundingRect().width()
+            if y2 is None:
+                y2 = topLeft.y() + img.boundingRect().height()
+            x2 = max(topLeft.x() + img.boundingRect().width(), x2)
+            y2 = max(topLeft.y() + img.boundingRect().height(), y2)
+
+        self.setX(x)
+        self.setY(y)
+        self.setWidth(x2 - x)
+        self.setHeight(y2 - y)
+
+    def setOrigin(self, *args):
+        self.set_P1(*args)
+
+    def set_P1(self, *args):
+        curP1 = self.get_P1()
+        Rect2D.set_P1(self, *args)
+        newP1 = self.get_P1()
+        for img in self:
+            img.translate(newP1.x() - curP1.x(), newP1.y() - curP1.y())
+
+        self.updateBoudingRect()
+
+    def translate(self, *args):
+        if len(args) == 1:
+            point = args[0]
+            QRectF.translate(self, point.x(), point.y())
+            for img in self:
+                img.translate(point.x(), point.y())
+        else:
+            QRectF.translate(self, args[0], args[1])
+            for img in self:
+                img.translate(QPointF(args[0], args[1]))
+
+    def __iter__(self):
+        ''' Returns the Iterator object '''
+        self._index = -1
+        return self
+
+    def __next__(self):
+        ''' Returns the next image or panel in the row '''
+        self._index += 1
+        if self._index < len(self.images):
+            return self.images[self._index]
+        # End of Iteration
+        raise StopIteration
+
+    # Forces the block to be of width (width_in_px)
+    def setToWidth(self, width_in_px):
+
+        # make all content same height then compute width and incompressible width of each object in fact
+
+        if width_in_px is None:
+            return
+        nb_cols = len(self)
+        pure_image_width = (self.boundingRect().width()) - (nb_cols - 1.) * self.space - self.getIncompressibleWidth()
+        # print(width_in_px, self.getIncompressibleWidth(), (nb_cols - 1.) * self.space)
+        width_in_px -= self.getIncompressibleWidth() + (nb_cols - 1.) * self.space
+        ratio = width_in_px / pure_image_width
+        for img in self:
+            img.setToHeight(img.boundingRect().width() * ratio)
+
+
+        self.packX(self.space)
+        self.updateBoudingRect()
+
+
+    # compute corresponding row height ???? so that it fits not so easy in fact
+
+    # pb here l'incompressible space est le courant plus la somme des incompressible spaces du contenu
+    # def setToWidth(self, width_in_px):
+    #
+    #     # make all content same height then compute width and incompressible width of each object in fact
+    #
+    #     if width_in_px is None:
+    #         return
+    #     nb_cols = len(self)
+    #     # pure_image_height = self.boundingRect().height() - self.getIncompressibleHeight()
+    #     # incompressible_width =  self.getIncompressibleWidth()
+    #
+    #     # for img in self:
+    #     #     incompressible_width+=img.getIncompressibleWidth()
+    #
+    #     pure_image_width = (self.boundingRect().width()) -self.getIncompressibleWidth(), (nb_cols - 1.) * self.space
+    #
+    #     # print(width_in_px, self.getIncompressibleWidth(), (nb_cols - 1.) * self.space)
+    #     width_in_px -= self.getIncompressibleWidth(), (nb_cols - 1.) * self.space
+    #     # height_in_px -= self.getIncompressibleHeight()
+    #     ratio = width_in_px / pure_image_width
+    #     for img in self:
+    #         print('target width before', width_in_px, img.boundingRect(), ratio)
+    #         img.setToWidth(img.boundingRect().width() * ratio)
+    #         print('target width after', width_in_px, img.boundingRect())
+    #
+    #
+    #     self.packX(self.space)
+    #     self.updateBoudingRect()
+
+    # Forces the block to be of width (width_in_px)
+    # tjrs faire ça row by row
+    def setToHeight(self, height_in_px):
+        # celui la marche mais celui du dessus ne marche pas --> pkoi ???
+
+        if height_in_px is None:
+            return
+        nb_cols = len(self) #ce ne sera pas tjrs correct --> faudrait faire mieux que ça en fait
+        # pure_image_width = (self.boundingRect().width()) -self.getIncompressibleWidth(), (nb_cols - 1.) * self.space
+        # incompressible_width = self.getIncompressibleWidth()
+
+        # for img in self:
+        #     incompressible_width += img.getIncompressibleWidth()
+        pure_image_width = (self.boundingRect().width()) - self.getIncompressibleWidth(), (nb_cols - 1.) * self.space
+
+        pure_image_height = self.boundingRect().height()- self.getIncompressibleHeight()
+        # print(height_in_px, self.getIncompressibleHeight(), (nb_cols - 1.) * self.space)
+        height_in_px -= self.getIncompressibleHeight()
+        ratio = height_in_px / pure_image_height
+        for img in self:
+            img.setToHeight(img.boundingRect().height() * ratio)
+
+        print('values resize', pure_image_width, pure_image_height, height_in_px, ratio)
+
+        self.packX(self.space)
+        self.updateBoudingRect()
+
+    def __len__(self):
+        if self.images is None:
+            return 0
+        return len(self.images)
+
+     # @return the block incompressible width
+    def getIncompressibleWidth(self):
+        return 0
+        #     # in fact need get nb of cols a
+        #     nb_cols = len(self)
+        #     extra_space = (nb_cols - 1.) * self.space
+        #     extra_space += self.getExtraIncompressibleWidth()
+        #     return extra_space
+        #
+    # def getExtraIncompressibleWidth(self):
+    #     extra_space = 0
+    #     return extra_space
+    #
+    # # @return the block incompressible height
+    def getIncompressibleHeight(self):
+        return 0
+        #     # in fact need get nb of cols a
+        #     nb_rows= len(self)
+        #     extra_space = (nb_rows - 1.) * self.space
+        #     extra_space += self.getExtraIncompressibleHeight()
+        #     return extra_space
+    #
+    # def getExtraIncompressibleHeight(self):
+    #     extra_space = 0
+    #     return extra_space
+
+    def packX(self, space=3):
+        last_x = 0
+        last_y = 0
+
+        for i in range(len(self.images)):
+            img = self.images[i]
+            if i != 0:
+                last_x += space
+            img.set_P1(last_x, img.get_P1().y())
+            last_x = img.boundingRect().x() + img.boundingRect().width()
+
+        self.updateBoudingRect()
+
+    def packY(self, space=3):
+        last_x = 0
+        last_y = 0
+
+        for i in range(len(self.images)):
+            img = self.images[i]
+            if i != 0:
+                last_y += space
+            img.set_P1(img.get_P1().x(), last_y)
+            # get all the bounding boxes and pack them with desired space in between
+            # get first point and last point in x
+            x = img.boundingRect().x()
+            y = img.boundingRect().y()
+            last_x = img.boundingRect().x() + img.boundingRect().width()
+            last_y = img.boundingRect().y() + img.boundingRect().height()
+        self.updateBoudingRect()
+
+    def alignTop(self, updateBounds=False):
+        first_left = None
+        for img in self:
+            cur_pos = img.get_P1()
+            if first_left is None:
+                first_left = cur_pos
+            img.set_P1(cur_pos.x(), first_left.y())
+        if updateBounds:
+            self.updateMasterRect()

batoolset/draw/widgets/image_organizer.py

@@ -0,0 +1,96 @@
+
+
+# TODO recode all from scratch rather than waisting time fixing it
+# do a row kind of element that aligns vertically
+
+
+# ça marche aussi maintenant reste plus qu'à faire le set width stuff set to width
+def sameHeight(things_to_align, space):
+
+    print('len(things_to_align)', len(things_to_align))
+    if space is None:
+        space = 0
+    max_height = None
+    # try:
+    #     iter(things_to_align)
+    for img in things_to_align:
+
+        if max_height is None:
+            max_height = img.boundingRect().height()
+        max_height = max(img.boundingRect().height(), max_height)
+        print('TUTU', img, type(img))
+        print('TUTA', img, img.boundingRect(), img.boundingRect().height)
+        print('TOTO', img, img.boundingRect(), img.boundingRect().height())
+
+
+    # why not looping till the end --> only gets one
+    count = 0
+    for img in things_to_align:
+        print(len(things_to_align), count)
+        count+=1
+        print('setting to height', max_height)
+        print('before 2', type(img))
+        img.setToHeight(max_height)
+        print('after 2', type(img), img.boundingRect())
+
+    print('max_height', max_height)
+
+    packX(things_to_align,space)
+    alignTop(things_to_align,updateBounds=False)
+    # things_to_align.updateBoudingRect()
+
+def packX(things_to_align, space=3):
+    last_x = 0
+    last_y = 0
+
+    for i in range(len(things_to_align)):
+        img = things_to_align[i]
+        if i != 0:
+            last_x += space
+        img.set_P1(last_x, img.get_P1().y())
+        last_x = img.boundingRect().x() + img.boundingRect().width()
+
+    # things_to_align.updateBoudingRect()
+
+def packY(things_to_align, space=3):
+    last_x = 0
+    last_y = 0
+
+
+    print('1',things_to_align)
+
+
+    for i in range(len(things_to_align)):
+        img = things_to_align[i]
+        print('2',img)
+        if isinstance(img, list):
+            from batoolset.draw.widgets.image_group import group
+            img = group(*img)
+        # should I create a row of objects in fact I need a group and move everything with that --> TODO --> maybe
+        if i != 0:
+            last_y += space
+
+        print('img', type(img))
+
+        img.set_P1(img.get_P1().x(), last_y)
+        # get all the bounding boxes and pack them with desired space in between
+        # get first point and last point in x
+        x = img.boundingRect().x()
+        y = img.boundingRect().y()
+        last_x = img.boundingRect().x() + img.boundingRect().width()
+        last_y = img.boundingRect().y() + img.boundingRect().height()
+    # things_to_align.updateBoudingRect()
+
+
+
+# Align vectorial objects to the top
+# in fact should align in y
+def alignTop(things_to_align, updateBounds=False):
+    first_left = None
+    for img in things_to_align:
+        cur_pos = img.get_P1()
+        if first_left is None:
+            first_left = cur_pos
+        img.set_P1(cur_pos.x(), first_left.y())
+    # if updateBounds:
+    #     things_to_align.updateMasterRect()