Jam/cross.py

import math
import sys
from kivy.graphics import Color,Line,Rectangle
from kivy.uix.widget import Widget
from kivy.core.window import Window

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,**kwargs):
        # set color
        if not self.selected:
            Color(*self.color)
        else:
            (r,g,b)=self.color
            # darken selected
            Color(r/2,g/2,b/2)

        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=[]

        # cross under mouse
        self.undermouse=None

        # list of selected crosses
        self.selected=[]

        # app is used to share information between widgets
        self.app=app

        # modifiers
        self.modifiers=[]

        # init Widget
        super(Cross_painter,self).__init__(**kwargs)

        # init keyboard
        self.keyboard = Window.request_keyboard(None,self,"text")
        self.keyboard.bind(on_key_down=self.on_key_down,on_key_up=self.on_key_up)

    
    def reset(self):
        self.crosses=[]
        self.undermouse=None
        self.draw()


    # draw all crosses
    def draw(self):
        self.canvas.clear()
        with self.canvas:
            for cross in self.crosses:
                cross.draw()


    # respond to keyboard
    def on_key_down(self, keyboard, keycode, text, modifiers):
        # check that command_prompt is not focused
        if not self.app.command_prompt.insert:
            if keycode[1]=="shift":
                if not 's' in self.modifiers:
                    self.modifiers.append('s')
                    self.modifiers.sort()

    def on_key_up(self, keyboard, keycode):
        if keycode[1]=="shift":
            if 's' in self.modifiers:
                # remove
                self.modifiers[self.modifiers.index('s')]=self.modifiers[len(self.modifiers)-1]
                self.modifiers=self.modifiers[:len(self.modifiers)-1]
                self.modifiers.sort()


    # 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)
                    # add to list
                    self.crosses.append(new)

                    # unselect all crosses
                    for sel in self.selected:
                        sel.selected=False
                    self.selected=[]

                    self.draw()

            # select cross
            if touch.button=="left":
                # find cross under touch
                self.undermouse=self.find_cross(Point(touch.x/Cross.size,touch.y/Cross.size))

                # no modifiers
                if self.modifiers==[]:
                    if self.undermouse==None or not self.undermouse in self.selected:
                        # unselect all crosses
                        for sel in self.selected:
                            sel.selected=False
                        self.selected=[]


                # shift-click
                elif self.modifiers==['s']:
                    if self.undermouse!=None:
                        if self.undermouse not in self.selected:
                            self.selected.append(self.undermouse)
                            self.undermouse.selected=True
                        else:
                            # remove
                            self.selected[self.selected.index(self.undermouse)]=self.selected[len(self.selected)-1]
                            self.selected=self.selected[:len(self.selected)-1]
                            self.undermouse.selected=False

                self.draw()


    # 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.undermouse!=None:
                self.undermouse.pos=self.check_move(Point(touch.x/Cross.size,touch.y/Cross.size),self.undermouse)
                # redraw
                self.draw()


    # 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)


    # write configuration to file
    def write(self,file):
        ff=open(file,"w")
        for cross in self.crosses:
            ff.write("{:05.2f},{:05.2f};{:3.1f},{:3.1f},{:3.1f}\n".format(cross.pos.x,cross.pos.y,cross.color[0],cross.color[1],cross.color[2]))
        ff.close()

    # read configuration from file
    def read(self,file):
        self.reset()
        try:
            ff=open(file,"r")
        except:
            self.app.command_prompt.message="error: could not read file '"+file+"' (this should not happen and is probably a bug)"
            return

        # counter
        i=0

        try:
            lines=ff.readlines()
        except:
            self.app.command_prompt.message="error: could not read the contents of file '"+file+"'"
            return

        for line in lines:
            i+=1

            # remove newline
            line=line[:len(line)-1]

            # ignore comments
            if '#' in line:
                line=line[:line.find('#')]
            # ignore empty lines
            if len(line)==0:
                continue

            entries=line.split(";")
            # skip line if improperly formatted
            if len(entries)>2:
                print("warning: ignoring line "+str(i)+" in file '"+file+"': more than two ';' spearated entries in '"+line+"'",file=sys.stderr)
                continue

            # position
            pos_str=entries[0].split(",")
            # skip line if improperly formatted
            if len(pos_str)!=2:
                print("warning: ignoring line "+str(i)+" in file '"+file+"': position '"+entries[0]+"' does not have two components",file=sys.stderr)
                continue
            try:
                pos=Point(float(pos_str[0]),float(pos_str[1]))
            except:
                print("warning: ignoring line "+str(i)+" in file '"+file+"': position '"+entries[0]+"' cannot be read",file=sys.stderr)
                continue
                

            # color
            color=(0,0,1)
            if len(entries)==2:
                color_str=entries[1].split(",")
                # skip line if improperly formatted
                if len(color_str)!=3:
                    print("warning: ignoring line "+str(i)+" in file '"+file+"': color '"+entries[1]+"' does not have three components",file=sys.stderr)
                    continue
                try:
                    color=(float(color_str[0]),float(color_str[1]),float(color_str[2]))
                except:
                    print("warning: ignoring line "+str(i)+" in file '"+file+"': color '"+entries[1]+"' cannot be read",file=sys.stderr)
                    continue

            if self.check_interaction_any(pos,None):
                # add to list
                self.crosses.append(Cross(pos.x,pos.y,color=color))
            else:
                print("warning: ignoring line "+str(i)+" in file '"+file+"': particle overlaps with existing particles",file=sys.stderr)
            
        ff.close()
        self.draw()