314 lines
12 KiB
Python
314 lines
12 KiB
Python
import math
|
|
import sys
|
|
from kivy.graphics import Color,Line,Rectangle
|
|
from kivy.uix.widget import Widget
|
|
|
|
from point import Point
|
|
from tools import isint_nonzero,sgn
|
|
|
|
class Cross():
|
|
# size of central square
|
|
size=50
|
|
|
|
def __init__(self,x,y,**kwargs):
|
|
self.pos=Point(x,y)
|
|
self.color=kwargs.get("color",(0,0,1))
|
|
self.selected=False
|
|
|
|
# set position
|
|
def setpos(self,x,y):
|
|
self.pos.x=x
|
|
self.pos.y=y
|
|
|
|
def draw(self):
|
|
Color(*(self.color))
|
|
Rectangle(pos=((self.pos.x-1.5)*self.size,(self.pos.y-0.5)*self.size),size=(3*self.size,self.size))
|
|
Rectangle(pos=((self.pos.x-0.5)*self.size,(self.pos.y-1.5)*self.size),size=(self.size,3*self.size))
|
|
|
|
# stroke
|
|
Color(1,1,1)
|
|
Line(points=(
|
|
*((self.pos.x-0.5)*self.size,(self.pos.y-0.5)*self.size),
|
|
*((self.pos.x-0.5)*self.size,(self.pos.y-1.5)*self.size),
|
|
*((self.pos.x+0.5)*self.size,(self.pos.y-1.5)*self.size),
|
|
*((self.pos.x+0.5)*self.size,(self.pos.y-0.5)*self.size),
|
|
*((self.pos.x+1.5)*self.size,(self.pos.y-0.5)*self.size),
|
|
*((self.pos.x+1.5)*self.size,(self.pos.y+0.5)*self.size),
|
|
*((self.pos.x+0.5)*self.size,(self.pos.y+0.5)*self.size),
|
|
*((self.pos.x+0.5)*self.size,(self.pos.y+1.5)*self.size),
|
|
*((self.pos.x-0.5)*self.size,(self.pos.y+1.5)*self.size),
|
|
*((self.pos.x-0.5)*self.size,(self.pos.y+0.5)*self.size),
|
|
*((self.pos.x-1.5)*self.size,(self.pos.y+0.5)*self.size),
|
|
*((self.pos.x-1.5)*self.size,(self.pos.y-0.5)*self.size),
|
|
*((self.pos.x-0.5)*self.size,(self.pos.y-0.5)*self.size),
|
|
))
|
|
|
|
# check whether a cross at pos interacts with cross
|
|
def check_interaction(self,pos):
|
|
# allow for error
|
|
return int(pos.x-self.pos.x+sgn(pos.x-self.pos.x)*1e-11)**2+int(pos.y-self.pos.y+sgn(pos.y-self.pos.y)*1e-11)**2>=5
|
|
|
|
# check whether a cross at position pos is touching self
|
|
def check_touch(self,pos):
|
|
rel=pos-self.pos
|
|
for i in [-3,-2,-1,1,2,3]:
|
|
# allow for error
|
|
if abs(rel.x-i)<1e-11 and abs(rel.y)<=4-abs(i)+1e-11 and abs(rel.y)>=3-abs(i)-1e-11:
|
|
return True
|
|
if abs(rel.y-i)<1e-11 and abs(rel.x)<=4-abs(i)+1e-11 and abs(rel.x)>=3-abs(i)-1e-11:
|
|
return True
|
|
return False
|
|
|
|
# find position along a line that comes in contact with the line going through pos in direction v
|
|
def move_on_line_to_stick(self,pos,v):
|
|
# relative to cross
|
|
return self.move_on_line_to_stick_relative(pos-self.pos,v)+self.pos
|
|
def move_on_line_to_stick_relative(self,x,v):
|
|
|
|
# if x is in the right quadrant
|
|
if abs(x.y)<=x.x:
|
|
# find all stuck positions on lines
|
|
stuck=[]
|
|
|
|
# check intersections with vertical lines
|
|
if v.x!=0:
|
|
for i in range(1,4):
|
|
# candidate
|
|
y=Point(i,x.y+(i-x.x)*v.y/v.x)
|
|
# check that it is in the right range
|
|
if abs(y.y)<=4-i and abs(y.y)>=3-i:
|
|
stuck.append(y)
|
|
# check intersections with horizontal lines
|
|
if v.y!=0:
|
|
for i in [-3,-2,-1,1,2,3]:
|
|
# candidate
|
|
y=Point(x.x+(i-x.y)*v.x/v.y,i)
|
|
# check that it is in the right range
|
|
if y.x<=4-abs(i) and y.x>=3-abs(i):
|
|
stuck.append(y)
|
|
|
|
return x.closest(stuck)
|
|
|
|
# reflect other quadrants to the right one
|
|
# top quadrant
|
|
elif abs(x.x)<=x.y:
|
|
closest=self.move_on_line_to_stick_relative(Point(x.y,x.x),Point(v.y,v.x))
|
|
return Point(closest.y,closest.x)
|
|
# bottom quadrant
|
|
elif abs(x.x)<=-x.y:
|
|
closest=self.move_on_line_to_stick_relative(Point(-x.y,x.x),Point(-v.y,v.x))
|
|
return Point(closest.y,-closest.x)
|
|
# left quadrant
|
|
else:
|
|
closest=self.move_on_line_to_stick_relative(Point(-x.x,x.y),Point(-v.x,v.y))
|
|
return Point(-closest.x,closest.y)
|
|
|
|
# move along edge of cross
|
|
def move_along(self,newpos,pos):
|
|
rel=pos-self.pos
|
|
# check if the particle is stuck in the x direction
|
|
if isint_nonzero(rel.x):
|
|
# check y direction
|
|
if isint_nonzero(rel.y):
|
|
# in corner
|
|
# two types of corners: |x|_1=3 or |x|_1=4
|
|
if abs(rel.x)+abs(rel.y)<3.5:
|
|
if sgn(newpos.y-pos.y)==sgn(rel.y):
|
|
# stuck in x direction
|
|
return self.move_stuck_x(newpos,pos)
|
|
elif sgn(newpos.x-pos.x)==sgn(rel.x):
|
|
# stuck in y direction
|
|
return self.move_stuck_y(newpos,pos)
|
|
else:
|
|
if sgn(newpos.y-pos.y)==-sgn(rel.y):
|
|
# stuck in x direction
|
|
return self.move_stuck_x(newpos,pos)
|
|
elif sgn(newpos.x-pos.x)==-sgn(rel.x):
|
|
# stuck in y direction
|
|
return self.move_stuck_y(newpos,pos)
|
|
# stuck in both directions
|
|
return pos
|
|
else:
|
|
# stuck in x direction
|
|
return self.move_stuck_x(newpos,pos)
|
|
elif isint_nonzero(rel.y):
|
|
# stuck in y direction
|
|
return self.move_stuck_y(newpos,pos)
|
|
# this should never happen
|
|
else:
|
|
print("error: stuck particle has non-integer relative position: (",rel.x,",",rel.y,")",file=sys.stderr)
|
|
exit(-1)
|
|
# move when stuck in the x direction
|
|
def move_stuck_x(self,newpos,pos):
|
|
# only move in y direction
|
|
candidate=Point(pos.x,newpos.y)
|
|
# do not move past corners
|
|
rel=pos.y-self.pos.y
|
|
newrel=newpos.y-self.pos.y
|
|
if newpos.y>pos.y:
|
|
if self.check_interaction(candidate)==False or (rel<math.ceil(rel)-1e-11 and newrel>math.ceil(rel)+1e-11 and math.ceil(rel)!=0):
|
|
# in open corner
|
|
if rel>math.ceil(rel)-1e-11:
|
|
candidate.y=math.ceil(rel)+1+self.pos.y
|
|
else:
|
|
candidate.y=math.ceil(rel)+self.pos.y
|
|
else:
|
|
if self.check_interaction(candidate)==False or (rel>math.floor(rel)+1e-11 and newrel<math.floor(rel)-1e-11 and math.floor(rel)!=0):
|
|
# in open corner
|
|
if rel<math.floor(rel)+1e-11:
|
|
candidate.y=math.floor(rel)-1+self.pos.y
|
|
else:
|
|
candidate.y=math.floor(rel)+self.pos.y
|
|
return candidate
|
|
# move when stuck in the y direction
|
|
def move_stuck_y(self,newpos,pos):
|
|
# only move in x direction
|
|
candidate=Point(newpos.x,pos.y)
|
|
# do not move past corners
|
|
rel=pos.x-self.pos.x
|
|
newrel=newpos.x-self.pos.x
|
|
if newpos.x>pos.x:
|
|
if self.check_interaction(candidate)==False or (rel<math.ceil(rel)-1e-11 and newrel>math.ceil(rel)+1e-11 and math.ceil(rel)!=0):
|
|
# in open corner
|
|
if rel>math.ceil(rel)-1e-11:
|
|
candidate.x=math.ceil(rel)+1+self.pos.x
|
|
else:
|
|
candidate.x=math.ceil(rel)+self.pos.x
|
|
else:
|
|
if self.check_interaction(candidate)==False or (rel>math.floor(rel)+1e-11 and newrel<math.floor(rel)-1e-11 and math.floor(rel)!=0):
|
|
# in open corner
|
|
if rel<math.floor(rel)+1e-11:
|
|
candidate.x=math.floor(rel)-1+self.pos.x
|
|
else:
|
|
candidate.x=math.floor(rel)+self.pos.x
|
|
return candidate
|
|
|
|
|
|
|
|
# L_infinity distance rescalled by 3 in the x direction
|
|
def cross_distx(x,y):
|
|
return max(abs(x.x-y.x)/3,abs(x.y-y.y))
|
|
# L_infinity distance rescalled by 3 in the y direction
|
|
def cross_disty(x,y):
|
|
return max(abs(x.x-y.x),abs(x.y-y.y)/3)
|
|
|
|
# polar description of touching cross
|
|
def cross_polar(t):
|
|
# by symmetry, put angle in interval (-pi/4,pi/4), and take absolute value
|
|
tt=abs((t+math.pi/4)%(math.pi/2)-math.pi/4)
|
|
if tt<math.atan(1/3):
|
|
return 3/math.cos(tt)
|
|
elif tt<math.atan(1/2):
|
|
return 1/math.sin(tt)
|
|
else:
|
|
return 2/math.cos(tt)
|
|
|
|
|
|
|
|
# cross painter
|
|
class Cross_painter(Widget):
|
|
|
|
def __init__(self,app,**kwargs):
|
|
|
|
# list of crosses
|
|
self.crosses=[]
|
|
|
|
# selected cross
|
|
self.selected=None
|
|
|
|
# app is used to share information between widgets
|
|
self.app=app
|
|
|
|
# init Widget
|
|
super(Cross_painter,self).__init__(**kwargs)
|
|
|
|
|
|
# draw all crosses
|
|
def draw(self):
|
|
with self.canvas:
|
|
for cross in self.crosses:
|
|
cross.draw()
|
|
|
|
|
|
# respond to mouse down
|
|
def on_touch_down(self,touch):
|
|
# only respond to touch in area
|
|
if self.collide_point(*touch.pos):
|
|
# create new cross
|
|
if touch.button=="right":
|
|
if self.check_interaction_any(Point(touch.x/Cross.size,touch.y/Cross.size),None):
|
|
new=Cross(touch.x/Cross.size,touch.y/Cross.size)
|
|
with self.canvas:
|
|
new.draw()
|
|
# add to list
|
|
self.crosses.append(new)
|
|
|
|
# select cross
|
|
if touch.button=="left":
|
|
# unselect
|
|
if self.selected!=None:
|
|
self.selected.selected=False
|
|
|
|
# find cross under touch
|
|
self.selected=self.find_cross(Point(touch.x/Cross.size,touch.y/Cross.size))
|
|
# select
|
|
if self.selected!=None:
|
|
self.selected.selected=True
|
|
|
|
|
|
# respond to drag
|
|
def on_touch_move(self,touch):
|
|
if self.collide_point(*touch.pos):
|
|
# only move on left click
|
|
if touch.button=="left" and self.selected!=None:
|
|
self.selected.pos=self.check_move(Point(touch.x/Cross.size,touch.y/Cross.size),self.selected)
|
|
# redraw
|
|
self.canvas.clear()
|
|
self.draw()
|
|
# report position in status bar
|
|
self.app.status_bar.set_position(" {:05.2f} , {:05.2f}".format(self.selected.pos.x,self.selected.pos.y))
|
|
|
|
|
|
# find the cross at position pos
|
|
def find_cross(self,pos):
|
|
for cross in self.crosses:
|
|
if cross_distx(pos,cross.pos)<=0.5 or cross_disty(pos,cross.pos)<=0.5:
|
|
return cross
|
|
# none found
|
|
return None
|
|
|
|
# check whether a position intersects with any of the crosses
|
|
def check_interaction_any(self,pos,exception):
|
|
for other in self.crosses:
|
|
if other!=exception:
|
|
if other.check_interaction(pos)==False:
|
|
return False
|
|
return True
|
|
|
|
# check that a cross can move to new position
|
|
def check_move(self,newpos,cross):
|
|
# whether newpos is acceptable
|
|
accept_newpos=True
|
|
for other in self.crosses:
|
|
# do not compare a cross to itself
|
|
if other!=cross:
|
|
# move would make cross overlap with other
|
|
if other.check_interaction(newpos)==False:
|
|
accept_newpos=False
|
|
# check if cross touches other
|
|
if other.check_touch(cross.pos):
|
|
# move along other while remaining stuck
|
|
candidate=other.move_along(newpos,cross.pos)
|
|
else:
|
|
candidate=other.move_on_line_to_stick(cross.pos,newpos-cross.pos)
|
|
if self.check_interaction_any(candidate,cross):
|
|
return candidate
|
|
if accept_newpos:
|
|
return newpos
|
|
else:
|
|
# cannot move cross at all, try again
|
|
return self.check_move(candidate,cross)
|
|
|
|
|
|
|