Jam/cross.py

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_text(" {: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)