1160 lines
33 KiB
Python
1160 lines
33 KiB
Python
#!/usr/bin/python
|
|
# coding: UTF-8
|
|
|
|
from string import *
|
|
from math import *
|
|
#from struct import *
|
|
import os
|
|
import sys
|
|
#import datetime
|
|
import locale
|
|
import re
|
|
TINY = 1e-6
|
|
SMALL = 1e-3
|
|
TEST_POINTS1 =[]
|
|
TEST_POINTS2 =[]
|
|
TEST_POINT_R = 0.01
|
|
|
|
PRE_IN_FLAG = -1
|
|
|
|
class POLYGON:
|
|
def __init__(self, x_min, x_max, y_min, y_max, points, delete):
|
|
self.x_min = x_min
|
|
self.x_max = x_max
|
|
self.y_min = y_min
|
|
self.y_max = y_max
|
|
self.points = points
|
|
self.delete = delete
|
|
|
|
class LINE:
|
|
def __init__(self, x1, y1, x2, y2, inside, delete):
|
|
self.x1 = x1
|
|
self.y1 = y1
|
|
self.x2 = x2
|
|
self.y2 = y2
|
|
self.inside = inside
|
|
self.delete = delete
|
|
def merge_lines(gGCODES):
|
|
print("merge lines ...")
|
|
i = 0
|
|
while i< len(gGCODES)-1:
|
|
if(gGCODES[i].gtype <= 2):
|
|
i += 1
|
|
continue
|
|
dx1 = gGCODES[i].x2-gGCODES[i].x1
|
|
dy1 = gGCODES[i].y2-gGCODES[i].y1
|
|
abs_dx1 = abs(dx1)
|
|
abs_dy1 = abs(dy1)
|
|
w1 = gGCODES[i].mod1
|
|
if gGCODES[i].gtype == 4:
|
|
w1 = gGCODES[i].mod2
|
|
x1min = gGCODES[i].x1
|
|
x1max = gGCODES[i].x2
|
|
if(gGCODES[i].x2<gGCODES[i].x1):
|
|
x1min = gGCODES[i].x2
|
|
x1max = gGCODES[i].x1
|
|
y1min = gGCODES[i].y1
|
|
y1max = gGCODES[i].y2
|
|
if(gGCODES[i].y2<gGCODES[i].y1):
|
|
y1min = gGCODES[i].y2
|
|
y1max = gGCODES[i].y1
|
|
if dx1 != 0:
|
|
a1 = (dy1)/(dx1)
|
|
b1 = gGCODES[i].y1 - a1 * gGCODES[i].x1
|
|
j = i + 1
|
|
#print("i =",i,", j =",j
|
|
while j< len(gGCODES):
|
|
if(gGCODES[j].gtype <= 2):
|
|
j += 1
|
|
continue
|
|
if(gGCODES[i].gtype <= 2):
|
|
#i += 1
|
|
break
|
|
if(abs_dy1 < TINY): #Line 1 is Horizontal
|
|
if (abs(gGCODES[j].y2-gGCODES[j].y1) < TINY): #Line 2 is Horizontal
|
|
w2 = gGCODES[j].mod1
|
|
if gGCODES[j].gtype == 4:
|
|
w2 = gGCODES[j].mod2
|
|
if abs(gGCODES[i].y1 - gGCODES[j].y1) < TINY:
|
|
#
|
|
x2min = gGCODES[j].x1
|
|
x2max = gGCODES[j].x2
|
|
if(gGCODES[j].x2<gGCODES[j].x1):
|
|
x2min = gGCODES[j].x2
|
|
x2max = gGCODES[j].x1
|
|
|
|
if (x2min <= x1min) and (x2max >= x1max) and (w2 >= w1):
|
|
gGCODES[i].gtype = 0
|
|
break
|
|
elif(x1min <= x2min) and (x1max >= x2max) and (w1 >= w2):
|
|
gGCODES[j].gtype = 0
|
|
j += 1
|
|
continue
|
|
elif abs(w1-w2) < TINY:
|
|
if (x1min <= x2min) and (x1max >= x2min):
|
|
if gGCODES[j].gtype == 3:
|
|
gGCODES[j].x2 = x2max
|
|
gGCODES[j].y2 = gGCODES[i].y1
|
|
gGCODES[j].x1 = x1min
|
|
gGCODES[j].y1 = gGCODES[i].y1
|
|
if gGCODES[i].gtype == 4 or (gGCODES[i].gtype == 5 and gGCODES[i].x1 <= gGCODES[i].x2):
|
|
gGCODES[j].gtype = 5
|
|
elif gGCODES[j].gtype == 5:
|
|
if gGCODES[j].x1 <= gGCODES[j].x2:
|
|
gGCODES[j].x1 = x1min
|
|
if gGCODES[i].gtype == 3 or (gGCODES[i].gtype == 5 and gGCODES[i].x1 >= gGCODES[i].x2):
|
|
gGCODES[j].gtype = 3
|
|
else: #gGCODES[j].x1 > gGCODES[j].x2
|
|
gGCODES[j].x2 = x1min
|
|
if gGCODES[i].gtype == 4 or (gGCODES[i].gtype == 5 and gGCODES[i].x1 <= gGCODES[i].x2):
|
|
gGCODES[j].gtype = 4
|
|
gGCODES[j].mod2 = w2
|
|
elif gGCODES[j].gtype == 4:
|
|
gGCODES[j].x2 = x1min
|
|
gGCODES[j].y2 = gGCODES[i].y1
|
|
gGCODES[j].x1 = x2max
|
|
gGCODES[j].y1 = gGCODES[i].y1
|
|
if gGCODES[i].gtype == 3 or (gGCODES[i].gtype == 5 and gGCODES[i].x1 >= gGCODES[i].x2):
|
|
gGCODES[j].gtype = 5
|
|
gGCODES[j].mod1 = w2
|
|
gGCODES[i].gtype = 0
|
|
break
|
|
elif (x2min <= x1min) and (x2max >= x1min):
|
|
if gGCODES[j].gtype == 3:
|
|
gGCODES[j].x2 = x2min
|
|
gGCODES[j].y2 = gGCODES[i].y1
|
|
gGCODES[j].x1 = x1max
|
|
gGCODES[j].y1 = gGCODES[i].y1
|
|
if gGCODES[i].gtype == 4 or (gGCODES[i].gtype == 5 and gGCODES[i].x1 >= gGCODES[i].x2):
|
|
gGCODES[j].gtype = 5
|
|
elif gGCODES[j].gtype == 5:
|
|
if gGCODES[j].x1 >= gGCODES[j].x2:
|
|
#gGCODES[j].x2 = x2min
|
|
gGCODES[j].x1 = x1max
|
|
if gGCODES[i].gtype == 3 or (gGCODES[i].gtype == 5 and gGCODES[i].x1 <= gGCODES[i].x2):
|
|
gGCODES[j].gtype = 3
|
|
else: #gGCODES[j].x1 < gGCODES[j].x2
|
|
gGCODES[j].x2 = x1max
|
|
#gGCODES[j].x1 = x1min
|
|
if gGCODES[i].gtype == 4 or (gGCODES[i].gtype == 5 and gGCODES[i].x1 >= gGCODES[i].x2):
|
|
gGCODES[j].gtype = 4
|
|
gGCODES[j].mod2 = w2
|
|
elif gGCODES[j].gtype == 4:
|
|
gGCODES[j].x2 = x1max
|
|
gGCODES[j].y2 = gGCODES[i].y1
|
|
gGCODES[j].x1 = x2min
|
|
gGCODES[j].y1 = gGCODES[i].y1
|
|
if gGCODES[i].gtype == 3 or (gGCODES[i].gtype == 5 and gGCODES[i].x1 <= gGCODES[i].x2):
|
|
gGCODES[j].gtype = 5
|
|
gGCODES[j].mod1 = w2
|
|
gGCODES[i].gtype = 0
|
|
break
|
|
elif abs(gGCODES[i].y1 - gGCODES[j].y1) <= (w2/2 + w1/2):
|
|
#print(w2/2 + w1/2, gGCODES[i].y1 - gGCODES[j].y1
|
|
#
|
|
x2min = gGCODES[j].x1
|
|
x2max = gGCODES[j].x2
|
|
if(gGCODES[j].x2 < gGCODES[j].x1):
|
|
x2min = gGCODES[j].x2
|
|
x2max = gGCODES[j].x1
|
|
#print("near"
|
|
#if gGCODES[i].gtype == 4 and gGCODES[j].gtype == 4:
|
|
if abs((x1max-x1min) - (x2max-x2min)) < SMALL: #same length
|
|
#print("same"
|
|
if abs((x1max+x1min)/2 - (x2max+x2min)/2) < SMALL: #same center
|
|
#print("center"
|
|
tmp_ymin = gGCODES[i].y1 - w1/2
|
|
tmp_ymax = gGCODES[j].y1 + w2/2
|
|
if tmp_ymin > gGCODES[j].y1 - w2/2:
|
|
tmp_ymin = gGCODES[j].y1 - w2/2
|
|
if tmp_ymax < gGCODES[i].y1 + w1/2:
|
|
tmp_ymax = gGCODES[i].y1 + w1/2
|
|
w2 = tmp_ymax - tmp_ymin
|
|
y2min = (tmp_ymax + tmp_ymin)/2
|
|
gGCODES[j].gtype = 4
|
|
gGCODES[j].mod2 = w2
|
|
#gGCODES[j].x2 = x2min
|
|
gGCODES[j].y2 = y2min
|
|
#gGCODES[j].x1 = x2min
|
|
gGCODES[j].y1 = y2min
|
|
gGCODES[i].gtype = 0
|
|
break
|
|
elif abs(gGCODES[j].x2-gGCODES[j].x1) < TINY: #Line 2 is Vertical
|
|
y2min = gGCODES[j].y1
|
|
y2max = gGCODES[j].y2
|
|
if(gGCODES[j].y2<gGCODES[j].y1):
|
|
y2min = gGCODES[j].y2
|
|
y2max = gGCODES[j].y1
|
|
if (gGCODES[i].y1 >= y2min and gGCODES[i].y1 <= y2max):
|
|
w2 = gGCODES[j].mod1
|
|
if gGCODES[j].gtype == 4:
|
|
w2 = gGCODES[j].mod2
|
|
if (abs(gGCODES[j].x1 - gGCODES[i].x1) < w2):
|
|
if gGCODES[i].gtype == 3:
|
|
gGCODES[i].gtype = 5
|
|
elif (abs(gGCODES[j].x1 - gGCODES[i].x2) < w2):
|
|
if gGCODES[i].gtype == 3:
|
|
gGCODES[i].gtype = 5
|
|
tmpx = gGCODES[i].x2
|
|
tmpy = gGCODES[i].y2
|
|
gGCODES[i].x2 = gGCODES[i].x1
|
|
gGCODES[i].y2 = gGCODES[i].y1
|
|
gGCODES[i].x1 = tmpx
|
|
gGCODES[i].y1 = tmpy
|
|
elif gGCODES[i].gtype == 5:
|
|
gGCODES[i].gtype = 4
|
|
gGCODES[i].mod2 = w1
|
|
j += 1
|
|
continue
|
|
elif(abs_dx1 < TINY): #Line 1 is Vertical
|
|
if (abs(gGCODES[j].y2-gGCODES[j].y1) < TINY): #Line 2 is Horizontal
|
|
w2 = gGCODES[j].mod1
|
|
if gGCODES[j].gtype == 4:
|
|
w2 = gGCODES[j].mod2
|
|
y2min = gGCODES[j].y1
|
|
y2max = gGCODES[j].y2
|
|
if(gGCODES[j].y2<gGCODES[j].y1):
|
|
y2min = gGCODES[j].y2
|
|
y2max = gGCODES[j].y1
|
|
if (gGCODES[j].y1 >= y1min and gGCODES[j].y1 <= y1max):
|
|
if (abs(gGCODES[i].x1 - gGCODES[j].x1) < w1):
|
|
if gGCODES[j].gtype == 3:
|
|
gGCODES[j].gtype = 5
|
|
#j += 1
|
|
#continue
|
|
elif (abs(gGCODES[i].x1 - gGCODES[j].x2) < w1):
|
|
w2 = gGCODES[j].mod1
|
|
if gGCODES[j].gtype == 4:
|
|
w2 = gGCODES[j].mod2
|
|
if gGCODES[j].gtype == 3:
|
|
gGCODES[j].gtype = 5
|
|
tmpx = gGCODES[j].x2
|
|
tmpy = gGCODES[j].y2
|
|
gGCODES[j].x2 = gGCODES[j].x1
|
|
gGCODES[j].y2 = gGCODES[j].y1
|
|
gGCODES[j].x1 = tmpx
|
|
gGCODES[j].y1 = tmpy
|
|
elif gGCODES[j].gtype == 5:
|
|
gGCODES[j].gtype = 4
|
|
gGCODES[j].mod2 = w2
|
|
j += 1
|
|
continue
|
|
elif abs(gGCODES[j].x2-gGCODES[j].x1) < TINY: #Line 2 is Vertical
|
|
#Overlap
|
|
w2 = gGCODES[j].mod1
|
|
if gGCODES[j].gtype == 4:
|
|
w2 = gGCODES[j].mod2
|
|
if abs(gGCODES[i].x1 - gGCODES[j].x1) < TINY:
|
|
y2min = gGCODES[j].y1
|
|
y2max = gGCODES[j].y2
|
|
if(gGCODES[j].y2<gGCODES[j].y1):
|
|
y2min = gGCODES[j].y2
|
|
y2max = gGCODES[j].y1
|
|
if (y2min <= y1min) and (y2max >= y1max) and (w2 >= w1):
|
|
gGCODES[i].gtype = 0
|
|
break
|
|
elif(y1min <= y2min) and (y1max >= y2max) and (w1 >= w2):
|
|
gGCODES[j].gtype = 0
|
|
j += 1
|
|
continue
|
|
#elif(y1max <= y2max) and (y2min <= y1max) and abs(w2-w1) < TINY:
|
|
elif abs(w1-w2) < TINY:
|
|
if (y1min <= y2min) and (y1max >= y2min):
|
|
if gGCODES[j].gtype == 3:
|
|
gGCODES[j].x2 = gGCODES[i].x1
|
|
gGCODES[j].y2 = y2max
|
|
gGCODES[j].x1 = gGCODES[i].x1
|
|
gGCODES[j].y1 = y1min
|
|
if gGCODES[i].gtype == 4 or (gGCODES[i].gtype == 5 and gGCODES[i].y1 <= gGCODES[i].y2):
|
|
gGCODES[j].gtype = 5
|
|
elif gGCODES[j].gtype == 5:
|
|
if gGCODES[j].y1 <= gGCODES[j].y2:
|
|
gGCODES[j].y1 = y1min
|
|
if gGCODES[i].gtype == 3 or (gGCODES[i].gtype == 5 and gGCODES[i].y1 >= gGCODES[i].y2):
|
|
gGCODES[j].gtype = 3
|
|
else: #gGCODES[j].y1 > gGCODES[j].y2
|
|
gGCODES[j].y2 = y1min
|
|
if gGCODES[i].gtype == 4 or (gGCODES[i].gtype == 5 and gGCODES[i].y1 <= gGCODES[i].y2):
|
|
gGCODES[j].gtype = 4
|
|
gGCODES[j].mod2 = w2
|
|
elif gGCODES[j].gtype == 4:
|
|
gGCODES[j].x2 = gGCODES[i].x1
|
|
gGCODES[j].y2 = y1min
|
|
gGCODES[j].x1 = gGCODES[i].x1
|
|
gGCODES[j].y1 = y2max
|
|
if gGCODES[i].gtype == 3 or (gGCODES[i].gtype == 5 and gGCODES[i].y1 >= gGCODES[i].y2):
|
|
gGCODES[j].gtype = 5
|
|
gGCODES[j].mod1 = w2
|
|
gGCODES[i].gtype = 0
|
|
break
|
|
elif (y2min <= y1min) and (y2max >= y1min):
|
|
if gGCODES[j].gtype == 3:
|
|
gGCODES[j].x2 = gGCODES[i].x1
|
|
gGCODES[j].y2 = y2min
|
|
gGCODES[j].x1 = gGCODES[i].x1
|
|
gGCODES[j].y1 = y1max
|
|
if gGCODES[i].gtype == 4 or (gGCODES[i].gtype == 5 and gGCODES[i].y1 >= gGCODES[i].y2):
|
|
gGCODES[j].gtype = 5
|
|
elif gGCODES[j].gtype == 5:
|
|
if gGCODES[j].y1 >= gGCODES[j].y2:
|
|
gGCODES[j].y1 = y1max
|
|
if gGCODES[i].gtype == 3 or (gGCODES[i].gtype == 5 and gGCODES[i].y1 <= gGCODES[i].y2):
|
|
gGCODES[j].gtype = 3
|
|
else: #gGCODES[j].y1 < gGCODES[j].y2
|
|
gGCODES[j].y2 = y1max
|
|
if gGCODES[i].gtype == 4 or (gGCODES[i].gtype == 5 and gGCODES[i].y1 >= gGCODES[i].y2):
|
|
gGCODES[j].gtype = 4
|
|
gGCODES[j].mod2 = w2
|
|
elif gGCODES[j].gtype == 4:
|
|
gGCODES[j].x2 = gGCODES[i].x1
|
|
gGCODES[j].y2 = y1min
|
|
gGCODES[j].x1 = gGCODES[i].x1
|
|
gGCODES[j].y1 = y2max
|
|
if gGCODES[i].gtype == 3 or (gGCODES[i].gtype == 5 and gGCODES[i].y1 <= gGCODES[i].y2):
|
|
gGCODES[j].gtype = 5
|
|
gGCODES[j].mod1 = w2
|
|
gGCODES[i].gtype = 0
|
|
break
|
|
elif abs(gGCODES[i].x1 - gGCODES[j].x1) < (w2/2 + w1/2):
|
|
#if gGCODES[i].gtype == 4 and gGCODES[j].gtype == 4:
|
|
y2min = gGCODES[j].y1
|
|
y2max = gGCODES[j].y2
|
|
if(gGCODES[j].y2<gGCODES[j].y1):
|
|
y2min = gGCODES[j].y2
|
|
y2max = gGCODES[j].y1
|
|
if abs((y1max-y1min) - (y2max-y2min)) < SMALL: #same length
|
|
if abs((y1max+y1min)/2 - (y2max+y2min)/2) < SMALL: #same center
|
|
tmp_xmin = gGCODES[i].x1 - w1/2
|
|
tmp_xmax = gGCODES[j].x1 + w2/2
|
|
if tmp_xmin > gGCODES[j].x1 - w2/2:
|
|
tmp_xmin = gGCODES[j].x1 - w2/2
|
|
if tmp_xmax < gGCODES[i].x1 + w1/2:
|
|
tmp_xmax = gGCODES[i].x1 + w1/2
|
|
w2 = tmp_xmax - tmp_xmin
|
|
x2min = (tmp_xmax + tmp_xmin)/2
|
|
gGCODES[j].gtype = 4
|
|
gGCODES[j].mod2 = w2
|
|
gGCODES[j].x2 = x2min
|
|
#gGCODES[j].y2 = y2max
|
|
gGCODES[j].x1 = x2min
|
|
#gGCODES[j].y1 = y1min
|
|
gGCODES[i].gtype = 0
|
|
break
|
|
j += 1
|
|
i += 1
|
|
return gGCODES
|
|
def check_duplication(gGCODES):
|
|
#global gGCODES,TINY
|
|
print("Check overlapping lines ...")
|
|
i = 0
|
|
|
|
while i< len(gGCODES)-1:
|
|
if(gGCODES[i].gtype == 0):
|
|
i += 1
|
|
continue
|
|
#m_x1_flag=0
|
|
#m_y1_flag=0
|
|
#xi1=gGCODES[i].x1
|
|
#yi1=gGCODES[i].y1
|
|
#xi2=gGCODES[i].x2
|
|
#yi2=gGCODES[i].y2
|
|
ti=gGCODES[i].gtype
|
|
xi_min=gGCODES[i].x1
|
|
xi_max=gGCODES[i].x2
|
|
yi_min=gGCODES[i].y1
|
|
yi_max=gGCODES[i].y2
|
|
if(gGCODES[i].x1>gGCODES[i].x2):
|
|
xi_min=gGCODES[i].x2
|
|
xi_max=gGCODES[i].x1
|
|
#m_x1_flag=1
|
|
if(gGCODES[i].y1>gGCODES[i].y2):
|
|
yi_min=gGCODES[i].y2
|
|
yi_max=gGCODES[i].y1
|
|
#m_y1_flag=1
|
|
dxi=gGCODES[i].x2-gGCODES[i].x1
|
|
dyi=gGCODES[i].y2-gGCODES[i].y1
|
|
if(abs(dxi) >= TINY):
|
|
ai=dyi/dxi
|
|
bi=gGCODES[i].y1-ai*gGCODES[i].x1
|
|
j = i + 1
|
|
while j< len(gGCODES):
|
|
if(gGCODES[j].gtype == 0):
|
|
j += 1
|
|
continue
|
|
if(gGCODES[i].gtype == 0):
|
|
#j += 1
|
|
break
|
|
#m_x2_flag=0
|
|
#m_y2_flag=0
|
|
xj1=gGCODES[j].x1
|
|
yj1=gGCODES[j].y1
|
|
xj2=gGCODES[j].x2
|
|
yj2=gGCODES[j].y2
|
|
tj=gGCODES[j].gtype
|
|
xj_min=xj1
|
|
xj_max=xj2
|
|
yj_min=yj1
|
|
yj_max=yj2
|
|
if(xj1>xj2):
|
|
xj_min=xj2
|
|
xj_max=xj1
|
|
#m_x2_flag=1
|
|
if(yj1>yj2):
|
|
yj_min=yj2
|
|
yj_max=yj1
|
|
#m_y2_flag=1
|
|
|
|
if(ti == tj): #same type
|
|
if(ti == 3 or ti == 4):
|
|
dxj=xj2-xj1
|
|
dyj=yj2-yj1
|
|
if(abs(dxi) >= TINY):
|
|
if(abs(dxj) >= TINY):
|
|
aj=dyj/dxj
|
|
bj=yj1-aj*xj1
|
|
if(abs(aj-ai) < TINY and abs(bj-bi) < TINY):
|
|
#print("a=" + str(ai)
|
|
if(xj_min>=xi_min):
|
|
#print("a"
|
|
if(xj_max<=xi_max):
|
|
#print("aa"
|
|
#overlap
|
|
if(gGCODES[i].mod1 >= gGCODES[j].mod1):
|
|
gGCODES[j].gtype=0
|
|
j += 1
|
|
continue
|
|
elif(xi_max >= xj_min): # xj_max > xi_max
|
|
if(gGCODES[i].mod1 == gGCODES[j].mod1):
|
|
#print("ab i=" +str(i) + ", j=" + str(j)
|
|
gGCODES[j].gtype=0
|
|
#gGCODES[i].x1 = xi_min
|
|
#gGCODES[i].y1 = gGCODES[i].y1
|
|
if(gGCODES[i].x1>gGCODES[i].x2): #if xi_min = gGCODES[i].x2
|
|
gGCODES[i].x1 = xi_min
|
|
gGCODES[i].y1 = gGCODES[i].y2
|
|
gGCODES[i].x2 = xj_max
|
|
gGCODES[i].y2 = yj2
|
|
xi_max = xj_max
|
|
if(xj1>xj2): #if xj_max = xj1
|
|
gGCODES[i].y2 = yj1
|
|
#j += 1
|
|
#continue
|
|
elif(xj_min<=xi_min):
|
|
#print("b"
|
|
if(xj_max>=xi_max):
|
|
#print("ba"
|
|
#overlap
|
|
if(gGCODES[i].mod1 <= gGCODES[j].mod1):
|
|
gGCODES[i].gtype=0
|
|
break
|
|
elif(xj_max >= xi_min): # xj_max < xi_max
|
|
if(gGCODES[i].mod1 == gGCODES[j].mod1):
|
|
#print("bb i=" +str(i) + ", j=" + str(j)
|
|
gGCODES[j].gtype=0
|
|
#print("x1=" +str(gGCODES[i].x1) +", y1=" +str(gGCODES[i].y1) +", x2=" +str(gGCODES[i].x2) +", y2=" +str(gGCODES[i].y2)
|
|
#gGCODES[i].x2 = xi_max
|
|
#gGCODES[i].y2 = gGCODES[i].y2
|
|
#if(m_x1_flag): #if xi_max = gGCODES[i].x1
|
|
if(gGCODES[i].x2 <= gGCODES[i].x1):
|
|
#gGCODES[i].x2 = xi_max
|
|
gGCODES[i].x2 = gGCODES[i].x1
|
|
gGCODES[i].y2 = gGCODES[i].y1
|
|
gGCODES[i].x1 = xj_min
|
|
gGCODES[i].y1 = gGCODES[j].y1
|
|
#xi_min = xj_min
|
|
if(xj1>xj2): #if xi_min = xj2
|
|
gGCODES[i].y1 = gGCODES[j].y2
|
|
xi_min = xj_min
|
|
#print("x1=" +str(gGCODES[i].x1) +", y1=" +str(gGCODES[i].y1) +", x2=" +str(gGCODES[i].x2) +", y2=" +str(gGCODES[i].y2)
|
|
#j += 1
|
|
#continue
|
|
else: #dxi==0
|
|
if(dxj==0 and gGCODES[i].x1==xj1):
|
|
if(yj_min>=yi_min):
|
|
if(yj_max<=yi_max):
|
|
if(gGCODES[i].mod1 >= gGCODES[j].mod1):
|
|
#overlap
|
|
gGCODES[j].gtype=0
|
|
#j += 1
|
|
#continue
|
|
elif(yi_max > yj_min):
|
|
if(gGCODES[i].mod1 == gGCODES[j].mod1):
|
|
gGCODES[j].gtype=0
|
|
#gGCODES[i].x1 = gGCODES[i].x1
|
|
gGCODES[i].y1 = yi_min
|
|
if(gGCODES[i].y1>gGCODES[i].y2): #yi_min = gGCODES[i].y2
|
|
gGCODES[i].x1 = gGCODES[i].x2
|
|
#gGCODES[i].y1 = yi_min
|
|
gGCODES[i].x2 = gGCODES[j].x2
|
|
gGCODES[i].y2 = yj_max
|
|
if(yj1>yj2):
|
|
gGCODES[i].x2 = gGCODES[j].x1
|
|
#j += 1
|
|
#continue
|
|
elif(yj_min<=yi_min):
|
|
if(yj_max>=yi_max):
|
|
if(gGCODES[i].mod1 <= gGCODES[j].mod1):
|
|
#overlap
|
|
gGCODES[i].gtype=0
|
|
break
|
|
elif(yj_max > yi_min):
|
|
if(gGCODES[i].mod1 == gGCODES[j].mod1):
|
|
#gGCODES[i].x2 = GCODES[i].x2
|
|
gGCODES[i].y2 = yi_max
|
|
if(gGCODES[i].y1>gGCODES[i].y2):
|
|
gGCODES[i].x2 = gGCODES[i].x1
|
|
#gGCODES[i].y2 = yi_max
|
|
gGCODES[i].x1 = GCODES[j].x1
|
|
gGCODES[i].y1 = yj_min
|
|
if(yj1>yj2):
|
|
gGCODES[i].x1 = GCODES[j].x2
|
|
#gGCODES[i].y1 = yj_min
|
|
else: #ti != tj
|
|
if(ti == 2):
|
|
if(tj == 3 or tj == 4):
|
|
#print("rect ti"
|
|
if(gGCODES[j].x1 == gGCODES[j].x2 and gGCODES[i].x1 == gGCODES[j].x1): #Vertical
|
|
#print("ti check x"
|
|
if(gGCODES[i].mod1 == gGCODES[j].mod1):
|
|
#print("ti check x mod1"
|
|
#line = [gGCODES[i].x1,gGCODES[i].y1-gGCODES[i].mod2/2,gGCODES[i].x1,gGCODES[i].y1+gGCODES[i].mod2/2]
|
|
x1=gGCODES[i].x1
|
|
y1=gGCODES[i].y1-gGCODES[i].mod2/2
|
|
x2=gGCODES[i].x1
|
|
y2=gGCODES[i].y1+gGCODES[i].mod2/2
|
|
xa=gGCODES[j].x1
|
|
ya=gGCODES[j].y1
|
|
xb=gGCODES[j].x2
|
|
yb=gGCODES[j].y2
|
|
ovflag = check_overlap(x1,y1,x2,y2,xa,ya,xb,yb,1)
|
|
if(ovflag): #Vertical 1-4
|
|
if(ovflag == 1):
|
|
gGCODES[j].gtype=0
|
|
if(ovflag == 3):
|
|
gGCODES[i].gtype=0
|
|
print("ti overlap =" + str(ovflag))
|
|
#print(line_joint(x1,y1,x2,y2,xa,ya,xb,yb,ovflag)
|
|
tx1,ty1,tx2,ty2=line_joint(x1,y1,x2,y2,xa,ya,xb,yb,ovflag)
|
|
if(tj == 4): #Rect
|
|
print("Rect-Rect")
|
|
gGCODES[j].gtype = 0
|
|
gGCODES[i].gtype = 4
|
|
gGCODES[i].x1 = tx1
|
|
gGCODES[i].y1 = ty1
|
|
gGCODES[i].x2 = tx2
|
|
gGCODES[i].y2 = ty2
|
|
elif(tj == 3):
|
|
print("rect-cir")
|
|
gGCODES[j].gtype = 0
|
|
gGCODES[i].gtype = 5
|
|
gGCODES[i].mod1 =gGCODES[j].mod1
|
|
gGCODES[i].x1 = tx1
|
|
gGCODES[i].y1 = ty1
|
|
gGCODES[i].x2 = tx2
|
|
gGCODES[i].y2 = ty2
|
|
if(ovflag == 4):
|
|
gGCODES[i].x1 = tx2
|
|
gGCODES[i].y1 = ty2
|
|
gGCODES[i].x2 = tx1
|
|
gGCODES[i].y2 = ty1
|
|
if(gGCODES[j].y1 == gGCODES[j].y2 and gGCODES[i].y1 == gGCODES[j].y1): #Horizontal
|
|
#print("ti check y"
|
|
if(gGCODES[i].mod2 == gGCODES[j].mod1):
|
|
#print("ti check y mod1"
|
|
#line = [gGCODES[i].x1-gGCODES[i].mod1/2,gGCODES[i].y1,gGCODES[i].x1+gGCODES[i].mod1/2,gGCODES[i].y1]
|
|
x1=gGCODES[i].x1-gGCODES[i].mod1/2
|
|
y1=gGCODES[i].y1
|
|
x2=gGCODES[i].x1+gGCODES[i].mod1/2
|
|
y2=gGCODES[i].y1
|
|
xa=gGCODES[j].x1
|
|
ya=gGCODES[j].y1
|
|
xb=gGCODES[j].x2
|
|
yb=gGCODES[j].y2
|
|
ovflag = check_overlap(x1,y1,x2,y2,xa,ya,xb,yb,0)
|
|
if(ovflag): #Horizontal 5-8
|
|
if(ovflag == 5):
|
|
gGCODES[j].gtype=0
|
|
if(ovflag == 7):
|
|
gGCODES[i].gtype=0
|
|
print("ti overlap =" + str(ovflag))
|
|
tx1,ty1,tx2,ty2=line_joint(x1,y1,x2,y2,xa,ya,xb,yb,ovflag)
|
|
|
|
if(tj == 4): #Rect
|
|
print("Rect-Rect")
|
|
gGCODES[j].gtype = 0
|
|
gGCODES[i].gtype = 4
|
|
gGCODES[i].x1 = tx1
|
|
gGCODES[i].y1 = ty1
|
|
gGCODES[i].x2 = tx2
|
|
gGCODES[i].y2 = ty2
|
|
elif(tj == 3):
|
|
print("rect-cir")
|
|
gGCODES[j].gtype = 0
|
|
gGCODES[i].gtype = 5
|
|
gGCODES[i].mod1 =gGCODES[j].mod1
|
|
gGCODES[i].x1 = tx1
|
|
gGCODES[i].y1 = ty1
|
|
gGCODES[i].x2 = tx2
|
|
gGCODES[i].y2 = ty2
|
|
if(ovflag == 8):
|
|
gGCODES[i].x1 = tx2
|
|
gGCODES[i].y1 = ty2
|
|
gGCODES[i].x2 = tx1
|
|
gGCODES[i].y2 = ty1
|
|
if(tj == 2):
|
|
if(ti == 3 or ti == 4):
|
|
#print("rect tj"
|
|
if(gGCODES[i].x1 == gGCODES[i].x2 and gGCODES[i].x1 == gGCODES[j].x1): #Vertical
|
|
#print("ti check x"
|
|
if(gGCODES[i].mod1 == gGCODES[j].mod1):
|
|
#print("ti check x mod1"
|
|
#line = [gGCODES[i].x1,gGCODES[i].y1-gGCODES[i].mod2/2,gGCODES[i].x1,gGCODES[i].y1+gGCODES[i].mod2/2]
|
|
x1=gGCODES[j].x1
|
|
y1=gGCODES[j].y1-gGCODES[j].mod2/2
|
|
x2=gGCODES[j].x1
|
|
y2=gGCODES[j].y1+gGCODES[j].mod2/2
|
|
xa=gGCODES[i].x1
|
|
ya=gGCODES[i].y1
|
|
xb=gGCODES[i].x2
|
|
yb=gGCODES[i].y2
|
|
ovflag = check_overlap(x1,y1,x2,y2,xa,ya,xb,yb,1)
|
|
if(ovflag): #Vertical 1-4
|
|
if(ovflag == 1):
|
|
gGCODES[j].gtype=0
|
|
if(ovflag == 3):
|
|
gGCODES[i].gtype=0
|
|
print("tj overlap =" + str(ovflag))
|
|
#print(line_joint(x1,y1,x2,y2,xa,ya,xb,yb,ovflag)
|
|
tx1,ty1,tx2,ty2=line_joint(x1,y1,x2,y2,xa,ya,xb,yb,ovflag)
|
|
if(tj == 4): #Rect
|
|
print("Rect-Rect")
|
|
gGCODES[j].gtype = 0
|
|
gGCODES[i].gtype = 4
|
|
gGCODES[i].x1 = tx1
|
|
gGCODES[i].y1 = ty1
|
|
gGCODES[i].x2 = tx2
|
|
gGCODES[i].y2 = ty2
|
|
elif(tj == 3):
|
|
print("rect-cir")
|
|
gGCODES[j].gtype = 0
|
|
gGCODES[i].gtype = 5
|
|
gGCODES[i].mod1 =gGCODES[j].mod1
|
|
gGCODES[i].x1 = tx1
|
|
gGCODES[i].y1 = ty1
|
|
gGCODES[i].x2 = tx2
|
|
gGCODES[i].y2 = ty2
|
|
if(ovflag == 4):
|
|
gGCODES[i].x1 = tx2
|
|
gGCODES[i].y1 = ty2
|
|
gGCODES[i].x2 = tx1
|
|
gGCODES[i].y2 = ty1
|
|
if(gGCODES[i].y1 == gGCODES[i].y2 and gGCODES[i].y1 == gGCODES[j].y1): #Horizontal
|
|
#print("ti check y"
|
|
if(gGCODES[i].mod1 == gGCODES[j].mod2):
|
|
|
|
x1=gGCODES[j].x1-gGCODES[j].mod1/2
|
|
y1=gGCODES[j].y1
|
|
x2=gGCODES[j].x1+gGCODES[j].mod1/2
|
|
y2=gGCODES[j].y1
|
|
xa=gGCODES[i].x1
|
|
ya=gGCODES[i].y1
|
|
xb=gGCODES[i].x2
|
|
yb=gGCODES[i].y2
|
|
ovflag = check_overlap(x1,y1,x2,y2,xa,ya,xb,yb,0)
|
|
if(ovflag): #Horizontal 5-8
|
|
if(ovflag == 5):
|
|
gGCODES[j].gtype=0
|
|
if(ovflag == 7):
|
|
gGCODES[i].gtype=0
|
|
print("tj overlap =" + str(ovflag))
|
|
tx1,ty1,tx2,ty2=line_joint(x1,y1,x2,y2,xa,ya,xb,yb,ovflag)
|
|
|
|
if(tj == 4): #Rect
|
|
print("Rect-Rect")
|
|
gGCODES[j].gtype = 0
|
|
gGCODES[i].gtype = 4
|
|
gGCODES[i].x1 = tx1
|
|
gGCODES[i].y1 = ty1
|
|
gGCODES[i].x2 = tx2
|
|
gGCODES[i].y2 = ty2
|
|
elif(tj == 3):
|
|
print("rect-cir")
|
|
gGCODES[j].gtype = 0
|
|
gGCODES[i].gtype = 5
|
|
gGCODES[i].mod1 =gGCODES[j].mod1
|
|
gGCODES[i].x1 = tx1
|
|
gGCODES[i].y1 = ty1
|
|
gGCODES[i].x2 = tx2
|
|
gGCODES[i].y2 = ty2
|
|
if(ovflag == 8):
|
|
gGCODES[i].x1 = tx2
|
|
gGCODES[i].y1 = ty2
|
|
gGCODES[i].x2 = tx1
|
|
gGCODES[i].y2 = ty1
|
|
j += 1
|
|
i +=1
|
|
return gGCODES
|
|
def line_joint(x1,y1,x2,y2,xa,ya,xb,yb,ovflag):
|
|
if(ovflag == 2): #Vertical 2
|
|
ox1=x1
|
|
oy1=y1
|
|
oy2=yb
|
|
ox2=x2
|
|
if(y1>y2):
|
|
oy1=y2
|
|
if(ya>yb):
|
|
oy2=ya
|
|
elif(ovflag == 4): #Vertical 4
|
|
ox1=x1
|
|
ox2=x2
|
|
oy1=ya
|
|
oy2=y2
|
|
if(y1>y2):
|
|
oy2=y1
|
|
if(ya>yb):
|
|
oy1=yb
|
|
elif(ovflag == 6): #Horizontal
|
|
ox1=x1
|
|
ox2=xb
|
|
oy1=y1
|
|
oy2=y2
|
|
if(x1>x2):
|
|
ox1=x2
|
|
if(xa>xb):
|
|
ox2=xa
|
|
elif(ovflag == 8): #Horizontal
|
|
ox1=xa
|
|
ox2=x2
|
|
oy1=y1
|
|
oy2=y2
|
|
if(x1>x2):
|
|
ox2=x1
|
|
if(xa>xb):
|
|
ox1=xb
|
|
else:
|
|
return (0,0,0,0)
|
|
return (ox1,oy1,ox2,oy2)
|
|
|
|
def check_overlap(x1,y1,x2,y2,xa,ya,xb,yb,sw):
|
|
if(sw): #Vertical
|
|
if(y2 < y1): #x2 < x1
|
|
tmpy = y1
|
|
y1 = y2
|
|
y2 = tmpy
|
|
if(yb < ya): #xb < xa
|
|
tmpy = ya
|
|
ya = yb
|
|
yb = tmpy
|
|
if(y1 <= ya and y2 >= ya):
|
|
if(y2 >= yb):
|
|
# line 2 is in line1
|
|
return 1
|
|
elif(y2 < yb):
|
|
return 2
|
|
elif(y1 <= yb and y2 >= yb):
|
|
return 4
|
|
elif(y1 > ya and y2 < yb):
|
|
return 3
|
|
else:
|
|
return 0
|
|
else: #Horizontal
|
|
if(x2 < x1): #x2 < x1
|
|
tmpx = x1
|
|
x1 = x2
|
|
x2 = tmpx
|
|
if(xb < xa): #xb < xa
|
|
tmpx = xa
|
|
xa = xb
|
|
xb = tmpx
|
|
if(x1 <= xa and x2 >= xa):
|
|
if(x2 >= xb):
|
|
# line 2 is in line1
|
|
return 5
|
|
elif(x2 < xb):
|
|
return 6
|
|
elif(x1 <= xb and x2 >= xb):
|
|
return 8
|
|
elif(x1 > xa and x2 < xb):
|
|
return 7
|
|
else:
|
|
return 0
|
|
|
|
def merge(gPOLYGONS, LINE, gLINES,gLINES2):
|
|
#global gPOLYGONS, gLINES,PRE_IN_FLAG,gLINES2
|
|
global PRE_IN_FLAG
|
|
gLINES = []
|
|
gLINES2 = []
|
|
for poly1 in gPOLYGONS:
|
|
PRE_IN_FLAG = -1
|
|
out_points=[]
|
|
if(poly1.delete):
|
|
continue
|
|
x_max=poly1.x_max
|
|
x_min=poly1.x_min
|
|
y_max=poly1.y_max
|
|
y_min=poly1.y_min
|
|
start_line_id=len(gLINES)
|
|
#polygon2line(poly1.points,0)
|
|
#global gLINES,gLINES2
|
|
i = 0
|
|
while i< len(poly1.points)-2:
|
|
gLINES.append(LINE(poly1.points[i],poly1.points[i+1],poly1.points[i+2],poly1.points[i+3],0,0))
|
|
i += 2
|
|
end_line_id=len(gLINES)
|
|
for poly2 in gPOLYGONS:
|
|
if(poly2.delete):
|
|
continue
|
|
if(poly1 == poly2):
|
|
continue
|
|
if(x_max < poly2.x_min or x_min > poly2.x_max):
|
|
continue
|
|
if(y_max < poly2.y_min or y_min > poly2.y_max):
|
|
continue
|
|
|
|
i = 0
|
|
while i< len(poly2.points)-2:
|
|
gLINES2.append(LINE(poly2.points[i],poly2.points[i+1],poly2.points[i+2],poly2.points[i+3],0,0))
|
|
i += 2
|
|
end_line_id2=len(gLINES2)
|
|
k = start_line_id
|
|
while k < end_line_id:
|
|
CrossAndIn(k,poly2.points,gLINES, LINE)
|
|
k += 1
|
|
end_line_id = len(gLINES)
|
|
|
|
for poly3 in gPOLYGONS:
|
|
#del all polygons
|
|
poly3.delete = 1
|
|
gPOLYGONS = line_merge(gPOLYGONS, gLINES)
|
|
print("End merge polygons")
|
|
return gPOLYGONS
|
|
|
|
def line_merge(gPOLYGONS, gLINES):
|
|
for line1 in gLINES:
|
|
if(line1.inside or line1.delete):
|
|
continue
|
|
tmp_points = [line1.x1, line1.y1, line1.x2, line1.y2]
|
|
line1.delete = 1
|
|
for line2 in gLINES:
|
|
if(line2.inside or line2.delete):
|
|
continue
|
|
if(len(tmp_points) > 3):
|
|
dist1 = calc_dist(tmp_points[0],tmp_points[1],line2.x2, line2.y2)
|
|
dist2 = calc_dist(tmp_points[len(tmp_points)-2],tmp_points[len(tmp_points)-1], line2.x1, line2.y1)
|
|
if(dist2 < TINY):
|
|
tmp_points = tmp_points + [line2.x2, line2.y2]
|
|
line2.delete = 1
|
|
elif(dist1 < TINY):
|
|
tmp_points = [line2.x1, line2.y1] + tmp_points
|
|
line2.delete = 1
|
|
gPOLYGONS.append(POLYGON(line1.x1, line1.x2, line1.y1, line1.y2,tmp_points,0))
|
|
merge_polygons(gPOLYGONS)
|
|
return gPOLYGONS
|
|
|
|
def merge_polygons(gPOLYGONS):
|
|
#global gPOLYGONS
|
|
print(" Start merge lines 2")
|
|
for poly1 in gPOLYGONS:
|
|
if(poly1.delete):
|
|
continue
|
|
tmp_points1 = poly1.points
|
|
for poly2 in gPOLYGONS:
|
|
if(poly2.delete or poly1==poly2):
|
|
continue
|
|
tmp_points2 = poly2.points
|
|
dist1 = calc_dist(tmp_points1[0],tmp_points1[1],tmp_points2[len(tmp_points2)-2],tmp_points2[-1])
|
|
dist2 = calc_dist(tmp_points1[len(tmp_points1)-2],tmp_points1[-1],tmp_points2[0],tmp_points2[1])
|
|
if(dist2 < TINY):
|
|
del tmp_points2[0:2]
|
|
tmp_points1 = tmp_points1 + tmp_points2
|
|
poly2.delete = 1
|
|
elif(dist1 < TINY and dist2 > TINY):
|
|
tmp_points2.pop()
|
|
tmp_points2.pop()
|
|
tmp_points1 = tmp_points2 + tmp_points1
|
|
poly2.delete = 1
|
|
poly1.points = tmp_points1
|
|
#disp_test_points()
|
|
|
|
def IsLineOverlap(x1,y1,x2,y2,xa,ya,xb,yb):
|
|
global TINY
|
|
#print("check overlap"
|
|
dx1 = x2-x1
|
|
#dy1 = y2-y1
|
|
dx2 = xb-xa
|
|
#dy2 = yb-ya
|
|
if(abs(dx1) < TINY): #Vertical
|
|
dx2 = xb-xa
|
|
if(abs(dx2) < TINY): #Vertical
|
|
if(abs(x1-xa) < TINY):
|
|
if (ya - y1)*(ya - y2) <=0 or (yb - y1)*(yb - y2) <=0:
|
|
return 1
|
|
else:
|
|
if(abs(dx2) > TINY): #not Vertical
|
|
dy1 = y2-y1
|
|
dy2 = yb-ya
|
|
a1 = (dy1)/(dx1)
|
|
#b1 = y1-a1*x1
|
|
a2 = (dy2)/(dx2)
|
|
#b2 = ya-a2*xa
|
|
if(abs(a1-a2) < TINY):
|
|
b1 = y1-a1*x1
|
|
b2 = ya-a2*xa
|
|
#print("same angle " + str(a1 )+ ", b1=" + str(b1)+ ", b2=" + str(b2) + ", b2-b1=" + str(abs(b2-b1)) +", y1=" +str(y1) + ", ya=" + str(ya)
|
|
if(abs(b2-b1) < TINY): #Horizontal
|
|
#print("same b " + str(b1)
|
|
if (xa - x1)*(xa - x2) <= 0 or (xb - x1)*(xb - x2):
|
|
return 1
|
|
return 0
|
|
|
|
def GetLineDist(line1,line2):
|
|
global TINY
|
|
dx = line1.x2-line1.x1
|
|
dy = line1.y2-line1.y1
|
|
a = dx * dx + dy * dy
|
|
if(a < TINY):
|
|
dist1 = calc_dist(line1.x1,line1.y1,line2.x1,line2.y1)
|
|
dist2 = calc_dist(line1.x1,line1.y1,line2.x2,line2.y2)
|
|
else:
|
|
b1 = dx * (line1.x1-line2.x1) + dy * (line1.y1-line2.y1)
|
|
b2 = dx * (line1.x1-line2.x2) + dy * (line1.y1-line2.y2)
|
|
t1 = - (b1 / a)
|
|
t2 = - (b2 / a)
|
|
if(t1 < 0.0):
|
|
t1 = 0.0
|
|
if(t1 > 1.0):
|
|
t1 = 1.0
|
|
if(t2 < 0.0):
|
|
t2 = 0.0
|
|
if(t2 > 1.0):
|
|
t2 = 1.0
|
|
x1 = t1 * dx + line1.x1
|
|
y1 = t1 * dy + line1.y1
|
|
x2 = t2 * dx + line1.x2
|
|
y2 = t2 * dy + line1.y2
|
|
dist1 = calc_dist(x1,y1,line2.x1,line2.y1)
|
|
dist2 = calc_dist(x2,y2,line2.x2,line2.y2)
|
|
|
|
if(abs(dist1-dist2) < TINY):
|
|
return dist1
|
|
else:
|
|
if(dist1 >= dist2):
|
|
return dist1
|
|
else:
|
|
return dist2
|
|
def CrossAndIn(line_id,spoints, gLINES, LINE):
|
|
#global gLINES, gCCOUNT1, gCCOUNT2,TEST_POINTS1,TEST_POINTS2
|
|
global gCCOUNT1, gCCOUNT2,TEST_POINTS1,TEST_POINTS2
|
|
#check in or out
|
|
#print(line_id
|
|
if(gLINES[line_id].inside):
|
|
return 0
|
|
xa = gLINES[line_id].x1
|
|
ya = gLINES[line_id].y1
|
|
xb = gLINES[line_id].x2
|
|
yb = gLINES[line_id].y2
|
|
cross_count1 = 0
|
|
cross_count2 = 0
|
|
cross_points = []
|
|
cross_nums = []
|
|
cross_num = 0
|
|
cross_flag = 0
|
|
tmp_flag = 0
|
|
return_flag = 0
|
|
ovflag = 0
|
|
si = 0
|
|
while si< len(spoints)-2:
|
|
xp1=spoints[si]
|
|
yp1=spoints[si+1]
|
|
xp2=spoints[si+2]
|
|
yp2=spoints[si+3]
|
|
if(IsLineOverlap(xa,ya,xb,yb,xp1,yp1,xp2,yp2)):
|
|
ovflag = 1
|
|
(cross_flag,cross_x,cross_y)=find_cross_point(xa,ya,xb,yb,xp1,yp1,xp2,yp2)
|
|
cross_num+=cross_flag
|
|
if(cross_flag):
|
|
#print("cross"
|
|
cross_points.extend([cross_x,cross_y])
|
|
cross_nums.append(si)
|
|
|
|
if ((ya <= yp1) and (ya > yp2)) or ((ya > yp1) and (ya <= yp2)):
|
|
#Cross?
|
|
if ((xa <= xp1) and (xa <= xp2)) or ((xa > xp1) and (xa > xp2)):
|
|
if(xa <= xp1):
|
|
#Cross
|
|
if(ya <= yp1):#
|
|
cross_count1 -=1
|
|
else:
|
|
cross_count1 += 1
|
|
elif(yp2 != yp1):#
|
|
if(xa <= (xp1+(xp2-xp1)*(ya-yp1)/(yp2-yp1))):#
|
|
if(ya <= yp1):#
|
|
cross_count1 -= 1
|
|
else:
|
|
cross_count1 += 1
|
|
|
|
|
|
|
|
if ((yb <= yp1) and (yb > yp2)) or ((yb > yp1) and (yb <= yp2)):
|
|
#Cross?
|
|
if ((xb <= xp1) and (xb <= xp2)) or ((xb > xp1) and (xb > xp2)):
|
|
if(xb <= xp1):
|
|
#Cross
|
|
if(yb <= yp1):#
|
|
cross_count2 -= 1
|
|
else:
|
|
cross_count2 += 1
|
|
elif(yp2 != yp1):#
|
|
if(xb <= (xp1+(xp2-xp1)*(yb-yp1)/(yp2-yp1))):#
|
|
if(yb <= yp1):#
|
|
cross_count2 -= 1
|
|
else:
|
|
cross_count2 += 1
|
|
|
|
si += 2
|
|
#end while
|
|
if(line_id == 1):
|
|
TEST_POINTS1.append([xa,ya])
|
|
TEST_POINTS1.append([xp1,yp1])
|
|
TEST_POINTS2.append([xb,yb])
|
|
TEST_POINTS2.append([xp2,yp2])
|
|
in_flag1 = 0
|
|
if(cross_count1):#
|
|
in_flag1 = 1
|
|
in_flag2 = 0
|
|
if(cross_count2):#
|
|
in_flag2 = 1
|
|
PRE_IN_FLAG = in_flag2
|
|
|
|
|
|
if(cross_num>1):
|
|
cross_points = sort_points_by_dist(xa,ya,cross_points)
|
|
#print(calc_dist(gLINES[line_id].x1,gLINES[line_id].y1,cross_points[0],cross_points[1])
|
|
if(calc_dist(gLINES[line_id].x1,gLINES[line_id].y1,cross_points[0],cross_points[1])<=0.0):
|
|
#print("the cross point is same as p1 in_flag1=" + str(in_flag1) + "in_flag2=" + str(in_flag2)
|
|
if(in_flag1 != in_flag2):
|
|
gLINES[line_id].inside = 1
|
|
else:
|
|
gLINES[line_id].inside = in_flag1
|
|
tmp_flag = in_flag1
|
|
tmp_x=gLINES[line_id].x1
|
|
tmp_y=gLINES[line_id].y1
|
|
else:
|
|
gLINES[line_id].x2 = cross_points[0]
|
|
gLINES[line_id].y2 = cross_points[1]
|
|
gLINES[line_id].inside = in_flag1
|
|
tmp_x=cross_points[0]
|
|
tmp_y=cross_points[1]
|
|
tmp_flag=1
|
|
if(in_flag1):
|
|
tmp_flag=0
|
|
i = 2
|
|
while i < len(cross_points)-2:
|
|
gLINES.append(LINE(tmp_x,tmp_y,cross_points[i],cross_points[i+1],tmp_flag,0))
|
|
tmp_flag = 1
|
|
if(in_flag1):
|
|
tmp_flag = 0
|
|
tmp_x=cross_points[i]
|
|
tmp_y=cross_points[i+1]
|
|
i += 2
|
|
#end while
|
|
if(calc_dist(cross_points[len(cross_points)-2],cross_points[len(cross_points)-1],xb,yb)>0.0):
|
|
gLINES.append(LINE(cross_points[len(cross_points)-2],cross_points[len(cross_points)-1],xb,yb,in_flag2,0))
|
|
|
|
elif(cross_num==1):
|
|
if(in_flag1 == in_flag2):
|
|
#in in
|
|
gLINES[line_id].inside=in_flag1
|
|
#print("in-in or Out-OUT:flag="+str(in_flag1)+ ", id=" +str(line_id)
|
|
else:
|
|
#in out
|
|
if(ovflag <=0):
|
|
gLINES[line_id].x2 = cross_points[0]
|
|
gLINES[line_id].y2 = cross_points[1]
|
|
gLINES[line_id].inside = in_flag1
|
|
gLINES.append(LINE(cross_points[0],cross_points[1],xb,yb,in_flag2,0))
|
|
else:
|
|
#overlap
|
|
gLINES[line_id].x2 = cross_points[0]
|
|
gLINES[line_id].y2 = cross_points[1]
|
|
gLINES[line_id].inside = 0
|
|
gLINES.append(LINE(cross_points[0],cross_points[1],xb,yb,0,0))
|
|
else:
|
|
gLINES[line_id].inside = in_flag1
|
|
|
|
if(cross_num > 0) or (in_flag1 or in_flag2):
|
|
return 1
|
|
|
|
return 0
|
|
def sort_points_by_dist(x,y,points):
|
|
return_points=[]
|
|
return_pos=[]
|
|
pre_dist=calc_dist(x,y,points[0],points[1])
|
|
i = 0
|
|
while i < len(points):
|
|
if(pre_dist > calc_dist(x,y,points[i],points[i+1])):
|
|
tmp_x = points[i]
|
|
tmp_y = points[i+1]
|
|
points[i] = points[i-2]
|
|
points[i+1] = points[i-1]
|
|
points[i-2] = tmp_x
|
|
points[i-1] = tmp_y
|
|
i += 2
|
|
return points
|
|
def calc_dist(x1,y1,x2,y2):
|
|
return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))
|
|
|
|
def find_cross_point(x1,y1,x2,y2,xa,ya,xb,yb):
|
|
#flag = 0
|
|
|
|
if(x1 == x2):
|
|
if(xa == xb):
|
|
return (0,0,0)
|
|
else:
|
|
aa=(yb-ya)/(xb-xa)
|
|
ba=ya-aa*xa
|
|
x=x1
|
|
y=aa*x+ba
|
|
else:
|
|
a1=(y2-y1)/(x2-x1)
|
|
b1=y1-a1*x1
|
|
if(xa == xb):
|
|
x=xa
|
|
y=a1*x+b1
|
|
else:
|
|
aa=(yb-ya)/(xb-xa)
|
|
ba=ya-aa*xa
|
|
if(a1 == aa):
|
|
return (0,0,0)
|
|
else:
|
|
x=(ba-b1)/(a1-aa)
|
|
y=a1*x+b1
|
|
|
|
x_max = x2
|
|
x_min = x1
|
|
if(x1 > x2):
|
|
x_max = x1
|
|
x_min = x2
|
|
if(x_min-TINY <= x and x_max+TINY >= x):
|
|
xa_max = xb
|
|
xa_min = xa
|
|
if(xa > xb):
|
|
xa_max=xa
|
|
xa_min=xb
|
|
if(xa_min-TINY <= x and xa_max+TINY>=x):
|
|
y_max = y2
|
|
y_min = y1
|
|
if(y1 > y2):
|
|
y_max=y1
|
|
y_min=y2
|
|
if(y_min-TINY <= y and y_max+TINY >= y):
|
|
ya_max = yb
|
|
ya_min = ya
|
|
if(ya > yb):
|
|
ya_max = ya
|
|
ya_min = yb
|
|
if(ya_min-TINY <= y and ya_max+TINY >= y):
|
|
return (1,x,y)
|
|
return (0,0,0)
|
|
|