~lorzeteam/lorze/trunk

#!/usr/bin/python

# -*- coding: utf-8 -*-

 

# LORZE erasandcad, a 2D CAD with an intuitive user interface, simple and easy.

# http://erasand.jimdo.com/python-programme/lorze/

# (C) 2012, Andreas Ulrich

 

# This file is part of “LORZE erasandcad“

 

# “LORZE erasandcad“ is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

 

# “LORZE erasandcad“ is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

 

# You should have received a copy of the GNU General Public License along with LORZE erasandcad.  If not, see <http://www.gnu.org/licenses/>.

 

import math

 

 

class LorzeGeoHelp():

    # Geometry helper object for LORZE erasandcad

 

    def __init__(self, options):

         # LORZE options

        self.__options= options

 

    def RectInRect(self, rect1, rect2):

        # check is rectangle in rectangle, return True of False, r1= (r1x, r1y, width1, height1), r2= (r2x, r2y, width2, height2), read the values

        r1x, r1y, r1w, r1h= rect1

        r2x, r2y, r2w, r2h= rect2

 

        # half width and height

        r1w2= r1w/ 2.0

        r1h2= r1h/ 2.0

        r2w2= r2w/ 2.0

        r2h2= r2h/ 2.0

 

        # distance between centers

        dx= abs((r1x+ r1w2)- (r2x+ r2w2))

        dy= abs ((r1y+ r1h2)- (r2y+ r2h2))

 

        if dx> (r1w2+ r2w2) or dy> (r1h2+ r2h2):

            # the distance between the centers of the rectangles ar too big

            return(False)

        else:

            # the rectangles ar inside each other

            return(True)

 

 

    def PointInRect(self, point, rect):

        # check is point in rectangle, return True or False, point= (px, py), rect= (rx, ry, width2, height2), read the values

        px, py= point

        rx, ry, rw, rh= rect

        rx2= rx+ rw

        ry2= ry+ rh

        if px>= rx and px<= rx2 and py>= ry and py<= ry2:

            # point is in the rechtanlge

            return(True)

        else:

            # point is not in the rectangle

            return(False)

 

 

    def PointOverSegment(self, segment, point, tolerance):

        # check is point over segment, return coordinate, (x, y) or None, segment= (sx1, sy1, sx2, r2y), point= (px, py), tolerance= value / read the values

        sx1, sy1, sx2, sy2= segment

        px, py= point

 

        # value to return

        value= None

 

        # get rectangle coordinates of the segment, height can be positive or negative

        sx, sy, sw, sh= self.LineXYtoWH(sx1, sy1, sx2, sy2)

 

        if sw== 0:

            # vertical line

            if sx>= (px- tolerance)  and sx<= (px+ tolerance):

                # rect over segment

                if sh>= 0 and sy<= py and (sy+ sh)>= py:

                    # point on segment found with positive height, return point

                    value= (sx, py)

                if sh< 0 and sy>= py and (sy+ sh)<= py:

                    # point on segment found with negative height, return point

                    value= (sx, py)

 

        elif sh== 0:

            # horizontal line

            if sy>= (py- tolerance) and sy<= (py+ tolerance):

                # rect over segment

                if sx<= px and (sx+ sw)>= px:

                    # point on segment found, return point

                    value= (px, sy)

 

        else:

            # oblique line / move segment to zero, correct point with the same amount

            px-= sx

            py-= sy

 

            #ratio height to width

            sa= sh/ float(sw)

 

            if sw>= sh:

                # >0 and <=45

                if px>= 0 and px<= sw:

                    # point is over segment, height of the point

                    ph= px* sa

                    if ph>= (py- tolerance) and ph<= (py+ tolerance):

                        # point found

                        foundy= px* sa

                        value= (px+ sx, foundy+ sy)

 

            else:

                # >45 and <90

                if py>= 0 and py<= sh:

                    # point is over segment, height of the point

                    pw= py/ sa

                    if pw>= (px- tolerance) and pw<= (px+ tolerance):

                        # point found

                        foundx= py/ sa

                        value= (foundx+ sx, py+ sy)

 

        return(value)

 

 

    def RectXYtoWH(self, x1, y1, x2, y2):

        # convert a rectangle x1, y1, x2, y2 to a rectangle, x, y, w, h

 

        if x1<= x2:

            x= x1

            w= x2- x1

        else:

            x= x2

            w= x1- x2

 

        if y1<= y2:

            y= y1

            h= y2- y1

        else:

            y= y2

            h= y1- y2

 

        return(x, y, w, h)

 

 

    def LineXYtoWH(self, x1, y1, x2, y2):

        # oblique line, move line at left point to zero point, move point with the same amount

        if x1> x2:

            # correct line, 1st point is on the right side, width & height segment

            w= x1- x2

            h= y1- y2

            # 1st point on the left side

            x, y= x2, y2

        else:

            # dont correct line, 1st point is on the left side, width & height segment

            w= x2- x1

            h= y2- y1

            # 1st point on the left side

            x, y= x1, y1

 

        return(x, y, w, h)

 

 

    def GetKar(self, angle, length):

        angle, length= float(angle), float(length) # set angle and length: float

 

        angle= self.CheckAngle(angle) # check over- underflow

 

        # get width and height from angle and length: float

        if length== 0:

            return (0, 0)

 

        a= math.radians(angle)

        w= math.cos(a)* length

        h= math.sin(a)* length

        width= round(w, self.__options.GetDezPlcs())

        height= round(h, self.__options.GetDezPlcs())

        return (width, height)

 

    def GetPol(self, width, height):

        # set width and height: float

        width, height= float(width), float(height)

 

        # get angle and length from width and height: float

        if width== 0 and height== 0:

            return (0, 0)

        elif width== 0 and height> 0:

            angle= 90

            length= height

        elif width== 0 and height< 0:

            angle= 270

            length= abs(height)

        elif width> 0 and height== 0:

            angle= 0

            length= width

        elif width< 0 and height== 0:

            angle= 180

            length= abs(width)

        else:

            w= abs(width)

            h= abs(height)

            a= math.degrees(math.atan(h/w))

            l= math.sqrt(h**2+ w**2)

            if height> 0 and width< 0:

                a= 180- a

            elif height< 0 and width< 0:

                a+= 180

            elif height<0 and width> 0:

                a= 360- a

            angle= round(a, self.__options.GetDezPlcs())

            length= round(l, self.__options.GetDezPlcs())

        return (angle, length)

 

            # Trigonometrie

            # width= a, height= g, length= h, angle= w

            # sin(w)= g/ h, g= sin(w)* h, h= g/ sin(w)

            # cos(w)= a/ h, a= cos(w)* h, h= a/ cos(w)

            # tan(w)= g/ a, g= tan(w)* a, a= g/ tan(w)

 

 

    def PointsMove(self, pointlist, dx, dy):

        # pointlist: [(x, y), (x, y), ..], dx, dy vector to move

        result= []

        for i in pointlist:

            x, y= i

            x+= dx

            y+= dy

            result.append((x, y))

        return(result)

 

 

    def PointsMirror(self, pointlist, xaxis, yaxis):

        # pointlist: [(x, y), (x, y), ..], xaxis, yaxis: axis to mirror, None for not mirror with this axis, get mirrored points (list)

        result= []

        for i in pointlist:

            x, y= i

            if xaxis!= None:

                x= xaxis- (x- xaxis)

            if yaxis!= None:

                y= yaxis- (y- yaxis)

            result.append((x, y))

        return(result)

 

 

    def PointsRot(self, pointlist, centx, centy, angle):

        # pointlist: [(x, y), (x, y), ..], anlge as float

        angle= float(angle)

 

        # check over- underflow

        angle= self.CheckAngle(angle)

 

        # select rotation and return result

        if angle== 0:

            result= pointlist

 

        elif angle== 180 or angle== -180:

            # get points with 180 degree rotated

            result= []

            for i in pointlist:

                x, y= i

                x= centx+ ((x-centx)* -1)

                y= centy+ ((y-centy)* -1)

                result.append((x, y))

 

        elif angle== 90 or angle== -90:

            # get points with 90 degree rotated

            result= []

            d= angle/ 90 # +90= 1, -90= -1

            for i in pointlist:

                x, y= i

                xnew= centx+ ((y- centy)* d* -1)

                ynew= centy+ ((x- centx)* d)

                result.append((xnew, ynew))

 

        elif angle== 270 or angle== -270:

            # get points with 270 degree rotated

            result= []

            d= angle/ 270 # +270= 1, -270= -1

            for i in pointlist:

                x, y= i

                xnew= centx+ ((y- centy)* d)

                ynew= centy+ ((x- centx)* d* -1)

                result.append((xnew, ynew))

        else:

            # get points with another angle rotated

            result= []

            a= math.radians(angle)

            for i in pointlist:

                x, y= i

                dx= x- centx

                dy= y- centy

                x= centx+ (dx)* math.cos(a) - (dy)* math.sin(a)

                y= centy+ (dx)* math.sin(a) + (dy)* math.cos(a)

                result.append((round(x, self.__options.GetDezPlcs()), round(y, self.__options.GetDezPlcs())))

 

        return(result)

 

            # Entwicklung der 90 Grad Drehformel

            # x+40, y  0, +90(x  0, y+40), -90(x  0, y-40), x=y*d*-1 , y=x*d

            # x  0, y+40, +90(x-40, y  0), -90(x+40, y  0), x=y*d*-1 , y=x*d

            # x-40, y  0, +90(x  0, y-40), -90(x  0, y+40), x=y*d*-1 , y=x*d

            # x  0, y-40, +90(x+40, y  0), -90(x-40, y  0), x=y*d*-1 , y=x*d

            # x+20, y+10, +90(x-10, y+20), -90(x+10, y-20), x=y*d*-1, y= x*d

            # x-10, y+20, +90(x-20, y-10), -90(x+20, y+10), x=y*d*-1, y= x*d

            # x-20, y-10, +90(x+10, y-20), -90(x-10, y+20), x=y*d*-1, y= x*d

            # x+10, y-20, +90(x+20, y+10), -90(x-20, y-10), x=y*d*-1, y= x*d

 

            # Formel 90 Grad Drehung

            # xnew= y- cy #Koordinaten tauschen, relativ zum Drehzentrum

            # xnew= xnew* d* -1 #Vorzeichen anpassen

            # xnew= cx+ xnew #Vom Drehzentrum zurückschieben

            # ynew= x- cx #Koordinaten tauschen, relativ zum Drehzentrum

            # ynew= ynew* d #Vorzeichen anpassen

            # ynew= cy+ ynew #Vom Drehzentrum zurückschieben

 

            # Formel Drehung

            # dx= x- cx

            # dy= y- cy

            # xnew= dx* math.cos(a) - dy* math.sin(a)

            # ynew= dx* math.sin(a) + dy* math.cos(a)

            # xnew= cx+ xnew

            # ynew= cy+ ynew

 

 

    def CheckAngle(self, angle):

        # check over- & underflow

        if angle >= 360:

            # angle overflow

            angle= angle% 360

        elif angle <= -360:

            # angle underflow

            angle= (abs(angle)% 360)* -1

        return(angle)

 

 

    def PointsScale(self, pointlist, centx, centy, factx, facty):

        # factors as float

        factx, facty= float(factx), float(facty)

 

        # get scaled point

        result= []

        for i in pointlist:

            x, y= i

            x= centx+ ((x- centx)* factx)

            y= centy+ ((y- centy)* facty)

            result.append((round(x, self.__options.GetDezPlcs()), round(y, self.__options.GetDezPlcs())))

        return(result)

 

 

    def IntersSegm(self, segment1, segmentlist):

        # find all intersections of a segment (x1, y1, x2, y2) and a segmentlist [(x1, y1, x2, y2), ..], return point- flaglist [(x, y, flag), ..], flag for True or False ist the intersection over the first segment

 

        # read segment1 coordinates

        x1, y1, x2, y2= segment1

 

        # get rectangle coordinates of the segment, height can be positive or negative

        x, y, w, h= self.LineXYtoWH(x1, y1, x2, y2)

 

        # polar coordinates of segment 1

        a, l= self.GetPol(w, h)

 

        # angke correction, rotate segment to 90 degrees

        corrangle= (a* -1)+ 90

 

        if corrangle!= 0:

            # objects has to be rotatet / generate pointlist from segment1 & segmentlist

            pointlist= [(x1, y1), (x2, y2)]

            for i in segmentlist:

                pointlist.append((i[0], i[1]))

                pointlist.append((i[2], i[3]))

 

            # rotate at point 0, 0

            pointsnew= self.PointsRot(pointlist, 0, 0, corrangle)

 

            # generate segment1 & segmentlist from pointlist

            x1, y1, x2, y2= pointsnew[0][0], pointsnew[0][1], pointsnew[1][0], pointsnew[1][1]

            segmentlist=[]

            for i in range(2, len(pointsnew), 2):

                segmentlist.append((pointsnew[i][0], pointsnew[i][1], pointsnew[i+ 1][0], pointsnew[i+ 1][1]))

 

            # rect of the segment 1

            x, y, w, h= self.LineXYtoWH(x1, y1, x2, y2)

 

        # set empty poinflaglist

        pointflaglist= []

 

        for i in segmentlist:

            # read segment coordinates, rectangle format

            sx, sy, sw, sh= self.LineXYtoWH(i[0], i[1], i[2], i[3])

 

            if sw== 0:

                # vertical segment

                foundflag= None

 

            elif sh== 0:

                # horizontal segment

                foundy= sy

                foundx= x

                if foundx>= sx and foundx<= (sx+ sw):

                    foundflag= True

                else:

                    foundflag= False

 

            else:

                # oblique line / calculate from x, y of the segment, correct x segment1

                xcorr= x- sx

 

                #ratio height to width

                sa= sh/ float(sw)

 

                # calculate intersection

                foundy= (xcorr* sa)+ sy

                foundx= x

 

                if h> 0 and foundy>= y and foundy<= y+ h:

                    # intersection point is over segment1

                    foundflag= True

                elif h< 0 and foundy<= y and foundy>= y+ h:

                    # intersection point is over segment1

                    foundflag= True

                else:

                    # intersection point is not over segment1

                    foundflag= False

 

            if foundflag!= None:

                pointflaglist.append((foundx, foundy, foundflag))

 

        if corrangle!= 0:

            # recorrect rotated objects / create pointlist and flaglist

            pointlist, flaglist= [], []

 

            for i in pointflaglist:

                # generate pointlist and flaglist

                pointlist.append((i[0], i[1]))

                flaglist.append(i[2])

 

            # rotate at point 0, 0

            pointsnew= self.PointsRot(pointlist, 0, 0, corrangle* -1)

 

            # generate pointsflaglist from pointsnew and flaglist

            pointflaglist= []

            for i in range(len(flaglist)):

                pointflaglist.append((pointsnew[i][0], pointsnew[i][1], flaglist[i]))

 

        return(pointflaglist)

 

 

if __name__== '__main__':

    from lrzoptions import LorzeOptions

 

    options= LorzeOptions()

    geohelp= LorzeGeoHelp(options)

 

    print('test RectInRect')

    print('---------------')

    print('should be False ..', geohelp.RectInRect((10, 10, 20, 20), (35, 35, 10, 10)))

    print('should be True ..', geohelp.RectInRect((10, 10, 20, 20), (-5, -5, 20, 20)))

    print('should be False ..', geohelp.RectInRect((-30, -10, 40, 50), (-33, 40, 2, 80)))

    print('should be True ..', geohelp.RectInRect((50, -10, 40, 1), (90, -40, 30, 30)))

 

    print('')

    print('test PointInRect')

    print('----------------')

    print('should be False ..', geohelp.PointInRect((5, 5), (2, 2, 4, 1)))

    print('should be True ..', geohelp.PointInRect((-7, 5), (-8, 4, 2, 2)))

 

    print('')

    print('test RectXYtoWH')

    print('------------------')

    print('should be 10, 10, 30, 20 ..', geohelp.RectXYtoWH(10, 10, 40, 30))

    print('should be 5, 10, 10, 70 ..', geohelp.RectXYtoWH(15, 80, 5, 10))

    print('should be 20, -20, 15, 110 ..', geohelp.RectXYtoWH(20, 90, 35, -20))

    print('should be -90, -12, 80, 10 ..', geohelp.RectXYtoWH(-10, -12, -90, -2))

 

    print('')

    print('Test PointOverSegment')

    print('---------------------')

    # horizontal positive

    print('should be 12, 10 ..', geohelp.PointOverSegment((10, 10, 20, 10), (12, 12), 3))

    print('should be None ..', geohelp.PointOverSegment((10, 10, 20, 10), (12, 14), 3))

    # horziontal negative

    print('should be -15, -10 ..', geohelp.PointOverSegment((-10, -10, -20, -10), (-15, -9), 2))

    print('should be None ..', geohelp.PointOverSegment((-10, -10, -20, -10), (-7, -9), 2))

    # vertical negative

    print('should be -10, -3 ..', geohelp.PointOverSegment((-10, 10, -10, -10), (-7, -3), 4))

    print('should be None ..', geohelp.PointOverSegment((-10, 10, -10, -10), (0, -15), 4))

    # vertical positive

    print('should be 20, -15 ..', geohelp.PointOverSegment((20, -5, 20, -15), (19, -15), 4))

    print('should be None ..', geohelp.PointOverSegment((20, -5, 20, -15), (19, -16), 4))

    # oblique 45 degrees

    print('should be 5, 5 ..', geohelp.PointOverSegment((0, 0, 10, 10), (5, 3), 2))

    print('should be None ..', geohelp.PointOverSegment((0, 0, 10, 10), (5, 2), 2))

    # oblique flat

    print('should be 28, -38 ..', geohelp.PointOverSegment((20, -40, 40, -35), (28, -40), 2))

    print('should be None ..', geohelp.PointOverSegment((20, -40, 40, -35), (28, -41), 2))

    # oblique steep

    print('should be -8, 42 ..', geohelp.PointOverSegment((10, -30, -10, 50), (-8, 40), 2))

    print('should be None ..', geohelp.PointOverSegment((10, -30, -10, 50), (-9, 40), 2))

 

    print('')

    print('Test GetKar')

    print('-----------')

    for t in [(0, 256, '256, 0'), (65, 269, '113.684312408, 243.796794713'), (90, 326, '0, 326'), (148, 728, '-617.379014002, 385.781224362'), (180, 369, '-369, 0'), (259, 236, '-45.030922909, -231.664015294'), (270, 268, '0, -268'), (326, 687, '569.548812345, -384.165524684'), (360, 265, '265, 0'), (785, 584, '246.809064857, 529.283747629'), (-53, 59, '35.507086366, -47.119495093'), (-90, 12, '0, -12'), (-159, 25, '-23.339510662, -8.959198739'), (-180, 35, '-35, 0'), (-218, 37, '-29.156397883, 22.779474587'), (-270, 26, '0, 26'), (-289, 27, '8.79034017, 25.529001541'), (-360, 59, '59, 0'), (-489, 43, '-27.060776815, -33.417276343')]:

        a, l, control= t

        print('should be',control)

        print('it is    ', geohelp.GetKar(a, l))

 

    print('')

    print('Test GetPol')

    print('-----------')

    for t in [(26, 0, '0, 26'), (65, 87, '53.235619324, 108.600184162'), (0, 69, '90, 69'), (-58, 56, '136.005086005, 80.622577483'), (-23, 0, '180, 23'), (-45, -39, '220.91438322, 59.548299724'), (0, -12, '270, 12'), (89, -28, '342.536073108, 93.300589494'), (256, 0, '0, 256'), (113.684312408, 243.796794713, '65, 269'), (0, 326, '90, 326'), (-617.379014002, 385.781224362, '148, 728'), (-369, 0, '180, 369'), (-45.030922909, -231.664015294, '259, 236'), (0, -268, '270, 268'), (569.548812345, -384.165524684, '326, 687'), (265, 0, '0, 265'), (246.809064857, 529.283747629, '65, 584'), (35.507086366, -47.119495093, '307, 59'), (0, -12, '270, 12'), (-23.339510662, -8.959198739, '201, 25'), (-35, 0, '180, 35'), (-29.156397883, 22.779474587, '142, 37'), (0, 26, '90, 26'), (8.79034017, 25.529001541, '71, 27'), (59, 0, '0, 59'), (-27.060776815, -33.417276343, '231, 43')]:

        w, h, control= t

        print('should be',control)

        print('it is    ', geohelp.GetPol(w, h))

 

    print('')

    print('Test PointsMove')

    print('---------------')

    pointlist=[(0, 0), (1, 1), (1, -1), (-1, -1), (-1, 1)]

    pointxt=''

    for i in [(1, 1, '(1, 1), (2, 2), (2, 0), (0, 0), (0, 2)'), (1, -1, '(1, -1), (2, 0), (2, -2), (0, -2), (0, 0)'), (-1, -1, '(-1, -1), (0, 0), (0, -2), (-2, -2), (-2, 0)'), (-1, 1, '(-1, 1), (0, 2), (0, 0), (-2, 0), (-2, 2)')]:

        x, y, control= i

        print('should be', control)

        print('it is    ', geohelp.PointsMove(pointlist, x, y))

 

    print('')

    print('Test PointsMirror')

    print('-----------------')

    pointlist=[(19, 17), (28, 64), (65, 59), (74, 30)]

    for i in [(0, 0, '(-19, -17), (-28, -64), (-65, -59), (-74, -30)'), (0, None, '(-19, 17), (-28, 64), (-65, 59), (-74, 30)'), (None, 0, '(19, -17), (28, -64), (65, -59), (74, -30)'), (10, None, '(1, 17), (-8, 64), (-45, 59), (-54, 30)'), (None, -20, '(19, -57), (28, -104), (65, -99), (74, -70)')]:

        x, y, control= i

        print('should be', control)

        print('it is    ', geohelp.PointsMirror(pointlist, x, y))

 

    print('')

    print('Test PointsRot')

    print('--------------')

    liste= [(0, [(25, 31)], 0, 0, '(25.0, 31.0'), (37, [(-48, 27), (25, 31)], -33, 12,

             '(-54.006758, 14.952307), (1.886374, 62.079346)'), (90, [(-3, -78)], -45, -99, '(-66.0, -57.0)'), (124, [(46, -2), (-3, -78)], -32, 67, '(-18.413454, 170.249241), (71.993854, 172.125061)'), (180, [(89, 0)], 0, 67, '(-89.0, 134.0)'), (212, [(0, 17), (-87, 0)], -53, 0, '(-88.937921, -42.502538), (-24.166365, 18.017255)'), (270, [(-87, 0)], 0, -65, '(65.0, 22.0)'), (303, [(0, -56), (-68, -68)], 13, 0, '(-41.045859, -19.597068), (-88.14536, 30.896862)'), (360, [(-68, -68)], -34, -34, '(-68.0, -68.0)'), (769, [(456, -789)], -6789, 3456, '(1167.889833, 6138.900331)'), (-360, [(25, 31)], 0, 0, '(25.0, 31.0)'), (-323, [(-48, 27), (25, 31)], -33, 12, '(-54.006758, 14.952307), (1.886374, 62.079346)'), (-270, [(-3, -78)], -45, -99, '(-66.0, -57.0)'), (-216, [(46, -2), (-3, -782)], -32, 67, '(-54.546143, 168.669423), (443.568186, 770.9012)'), (-180, [(89, 0)], 0, 67, '(-89.0, 134.0)'), (-148, [(0, 17), (-87, 0)], -53, 0, '(-88.937921, -42.502538), (-24.166365, 18.017255)'), (-90, [(-87, 0)], 0, -65, '(65.0, 22.0)'), (-57, [(0, -56), (-68, -68)], 13, 0, '(-41.045859, -19.597068), (-88.14536, 30.896862)'), (0, [(-68, -68)], -34, -34, '(-68.0, -68.0)'), (-1031, [(456, -789)], -6789, 3456, '(1167.889833, 6138.900331)')]

    for i in liste:

        angle, pointlist, cx, cy, control= i

        print('should be', control)

        print('it is    ', geohelp.PointsRot(pointlist, cx, cy, angle))

 

    print('')

    print('Test PointsScale')

    print('----------------')

    pointlist=[(0, 0), (10, 10), (20, -30), (-40, -50), (-60, 70)]

    for i in [(1, 1, 0, 0, '(0.0, 0.0), (10.0, 10.0), (20.0, -30.0), (-40.0, -50.0), (-60.0, 70.0)'), (2, 3, 4, 5, '(-4.0, -10.0), (16.0, 20.0), (36.0, -100.0), (-84.0, -160.0), (-124.0, 200.0)'), (0.25, 0.5, -2, -4, '(-1.5, -2.0), (1.0, 3.0), (3.5, -17.0), (-11.5, -27.0), (-16.5, 33.0)')]:

        fx, fy, cx, cy, control= i

        print('should be', control)

        print('it is    ', geohelp.PointsScale(pointlist, cx, cy, fx, fy))

 

    print('')

    print('LineXYtoWH')

    print('----------')

    print('10, 8, 20, 10 should be 10, 8, 10, 2 / it is', geohelp.LineXYtoWH(10, 8, 20, 10))

    print('-2, -6, -20, 30 should be -20, 30, 18, -36 / it is', geohelp.LineXYtoWH(-2, -6, -20, 30))

    print('-3, -3, -30, -20 should be -30, -20, 27, 17 / it is', geohelp.LineXYtoWH(-3, -3, -30, -20))

    print('6, -4, 50, -16 should be 6, -4, 44, -12 / it is', geohelp.LineXYtoWH(6, -4, 50, -16))

    x, y, w, h= geohelp.LineXYtoWH(10, 0, 10, 20)

    a, l= geohelp.GetPol(w, h)

    print('10, 0, 10, 20: LineXYtoWH=', x, y, w, h, ' / angle & lenth=', a, l)

    x, y, w, h= geohelp.LineXYtoWH(10, 20, 10, 0)

    a, l= geohelp.GetPol(w, h)

    print('10, 20, 10, 0: LineXYtoWH=', x, y, w, h, ' / angle & lenth=', a, l)

 

    print('')

    print('Test IntersSegm')

    print('---------------')

    testlist= [(10, 20, 40, 20), (-100, -10, -10, 30), (-40, 20, -40, -60), (5, -5, 20, -70)]

    print('should be (15.0, 20.0, False), (15.0, approx 41, False), (15.0, approx -48, True)')

    print('it is', geohelp.IntersSegm((15, -60, 15, -5), testlist))

    print('should be (approx -21, 25.0, True), (-40.0, 25.0, False), (approx -2, 25.0, False)')

    print('it is', geohelp.IntersSegm((-35, 25, -5, 25), testlist))

    print('should be (approx 214, 20.0, False), (approx -149, approx -32, False), (-40.0, approx -16, True), (approx 6, approx -10, True')

    print('it is', geohelp.IntersSegm((11, -9, -59, -19), testlist))

 

    print('should be (approx -3, 20.0, True), (approx -13, approx 28, True), (-40.0, approx 49, False), (approx 0, approx 18, True')

    print('it is', geohelp.IntersSegm((-18, 32, 11, 9), testlist))