O que está errado com a minha pressão para código de rede?

Question

Primeiro de tudo, eu estou bastante certo agarrar a grade é bastante fácil, no entanto eu correr em alguns problemas estranho nesta situação e minha matemática são demasiado fracos para trabalhar especificamente o que está errado.

Aqui está a situação

Eu tenho um conceito abstrato de uma grade, com Y passos exatamente Y_STEP apart (os passos x estão funcionando bem assim ignorá-los para agora)

A grade está em um espaço de coordenadas abstrato, e para fazer as coisas para a linha até eu tenho um deslocamento lá mágica, vamos chamá-lo Y_OFFSET

para ajustar à grade Eu tenho o seguinte código (python)

def snapToGrid(originalPos, offset, step):
    index = int((originalPos - offset) / step) #truncates the remainder away
    return index * gap + offset

então eu passar a posição do cursor, Y_OFFSET e Y_STEP nessa função e ele me devolve a posição y piso mais próximo da grade

Isso parece funcionar bem no cenário original, no entanto, quando eu levar em conta o fato de que a vista é coisas rolagem ficar um pouco estranho.

Scrolling é feita tão básico como posso obtê-lo, eu tenho uma janela que mantém a contagem da distância rolada ao longo do eixo Y e apenas compensa tudo o que passa por ele.

Aqui está um trecho de código mouseMotion do cursor:

def mouseMotion(self, event):
    pixelPos = event.pos[Y]
    odePos = Scroll.pixelPosToOdePos(pixelPos)
    self.tool.positionChanged(odePos)

Portanto, há duas coisas a olhar para lá, primeira tradução do módulo Scroll da posição do pixel para o abstrato espaço de coordenadas, então a função PositionChanged da ferramenta que leva o abstrato valor de coordenadas de espaço e snaps para a etapa de Y mais próximo.

Aqui está o código Scroll relevantes

def pixelPosToOdePos(pixelPos):
    offsetPixelPos = pixelPos - self.viewPortOffset
    return pixelsToOde(offsetPixelPos)

def pixelsToOde(pixels):
    return float(pixels) / float(pixels_in_an_ode_unit)

E o código ferramentas de atualização

def positionChanged(self, newPos):
    self.snappedPos = snapToGrid(originalPos, Y_OFFSET, Y_STEP)

A última parcela relevante é quando a ferramenta vai para tornar-se. Ela passa por objeto Scroll, que transforma os da ferramenta estalou coordenar a posição espaço em uma posição de pixel na tela, aqui está o código:

#in Tool
def render(self, screen):
    Scroll.render(screen, self.image, self.snappedPos)

#in Scroll
def render(self, screen, image, odePos):
    pixelPos = self.odePosToPixelPos(odePos)
    screen.blit(image, pixelPos) # screen is a surface from pygame for the curious

def odePosToPixelPos(self.odePos):
    offsetPos = odePos + self.viewPortOffset
    return odeToPixels(offsetPos)

def odeToPixels(odeUnits):
    return int(odeUnits * pixels_in_an_ode_unit)

Ufa, essa foi uma longa explicação. Espero que você ainda está comigo ...

O problema que estou começando agora é que quando eu rolar para cima a imagem desenhada perde alinhamento com o cursor.
Ele começa a agarrar ao passo Y exatamente 1 degrau abaixo do cursor. Além disso, ele parece fase dentro e fora de allignment.
Em alguns pergaminhos ele está fora por 1 e outros pergaminhos que está no local.
Nunca é por mais de 1 e está sempre tirando para um local da rede válido.

Melhor acho que posso chegar é que em algum lugar eu estou truncar alguns dados no lugar errado, mas nenhuma idéia de onde ou como ele acaba com esse comportamento.

Qualquer pessoa familiarizada com espaços de coordenadas, rolando e estalando?

Answer 1

Ok, eu estou respondendo a minha própria pergunta aqui, como Alexk mencionado, usando int para truncar foi meu erro.

O comportamento que eu estou atrás é melhor modelado por Math.floor ().

Apologies, a pergunta original não contém informação suficiente para realmente descobrir o que é o problema. Eu não tinha a pouco mais de informações nesse ponto.

Com relação à nota erro de digitação, eu acho que pode ser usando o contexto de uma maneira confuso ... Do ponto de vista da função PositionChanged (), o parâmetro é uma nova posição entrando.
Do ponto de vista da função SnapToGrid () o parâmetro é uma posição original que está a ser mudada para uma posição de encaixado. A linguagem é assim, porque parte dela está no meu código de manipulação de eventos ea outra parte está no meu código de serviços gerais. Eu deveria ter mudado para o exemplo

Answer 2

Você tem um erro de digitação no PositionChanged ()?

def positionChanged(self, newPos):
    self.snappedPos = snapToGrid(newPos, Y_OFFSET, Y_STEP)

Eu acho que você está fora por um pixel por causa dos problemas de precisão durante a divisão float. Tente alterar o seu SnapToGrid () para o seguinte:

def snapToGrid(originalPos, offset, step):
    EPS = 1e-6
    index = int((originalPos - offset) / step  + EPS) #truncates the remainder away
    return index * gap + offset

Answer 3

Obrigado pela resposta, pode haver um erro de digitação, mas eu não posso ver isso ...

Infelizmente a mudança para SnapToGrid não fazer a diferença, então eu não acho que esse é o problema.

Não é off por um pixel, mas ele está fora por Y_STEP. Brincar com ele um pouco mais eu descobri que eu não posso obtê-lo para ser exato em qualquer ponto que a tela é rolada para cima e também que isso acontece em direção ao topo da tela, que eu suspeito que é a posição ODE zero, de modo Eu estou supondo que o meu problema é em torno de valores pequenos ou negativos.