W dniu poniedziałek, 13 marca 2017 15:46:29 UTC+1 użytkownik fir napisał:
> W dniu poniedziałek, 13 marca 2017 12:38:15 UTC+1 użytkownik bartekltg napisał:
> > On 13.03.2017 01:15, fir wrote:
> > > W dniu niedziela, 12 marca 2017 23:47:04 UTC+1 użytkownik fir napisał:
> > >> W dniu niedziela, 12 marca 2017 23:23:35 UTC+1 użytkownik fir napisał:
> > >>> W dniu niedziela, 12 marca 2017 22:57:05 UTC+1 użytkownik bartekltg napisał:
> > >>>> On 12.03.2017 22:46, fir wrote:
> > >>>>> szukam dosyc prostego algorytmu
> > >>>>>
> > >>>>> mam punkt int x,y np 0,0
> > >>>>> i chce znalezc nastepny punkt
> > >>>>> w kierunku jakiegos dowolnego punktu
> > >>>>> int dist_x, dist_y, tak jak gdybym
> > >>>>> rysowal linie prostą
> > >>>>>
> > >>>>> jak wzynaczyc ten przylegly punkt?
> > >>>>>
> > >>>>
> > >>>> Algorytm Bresenhama
> > >>>>
> > >>> raczej fragment bressenhama ale jaki
> >
> > Z testów wygląda, że całego.
> >
> >
> >
> > >>
> > >> w sumie to chyba bedzie cos takiego
> > >>
> > >> int2 NextPointTowards(int x, int y, int dest_x, int dest_y)
> > >> {
> > >> int2 n = {x, y};
> > >>
> > >> int dx = dest_x - x;
> > >> int dy = dest_y - y;
> > >>
> > >> int sx = sign(dx);
> > >> int sy = sign(dy);
> > >>
> > >> if(sx==0) n.y += sy;
> > >> else if(sy==0) n.x += sx;
> > >> else
> > >> {
> > >> float m = fabs(((float)dy)/dx);
> >
> > a to da się zrobić bez floatów. Choćby tak:
> > if ( 2*abs(dx) < abs(dy) )...
> > else if ( abs(dx) > 2*abs(dy) )...
> >
> > >>
> > >> if( m < 0.5) n.x += sx;
> > >> else if( m > 2.0) n.y += sy;
> > >> else { n.x += sx; n.y += sy; }
> > >> }
> > >>
> > >> return n;
> > >>
> > >> }
> > >>
> > >> mozna by wywalic dzielenie zastepujac ifem ale nie wiedomo czy if szybszy
> > >>
> > >> pozatym w dzialaniu to chyba nie zastpi bresenhama (trzebby sprawdzic) choc mw
o to mi chodzi bo taka procedura jest jaby bardziej ogolna
> > >
> > > zrobilem testy i okazalo sie ze to nie dziala dobrze
> >
> > >
> > > http://minddetonator.htw.pl/compact.jpg
> > >
> > > gorna linia to normalne a dolna dolna linia to wynik generowania tych punktow
> > > wyzej
> >
> > Nic dziwnego. Ten kod pozwala na wybór jednego z 8 kierunków.
> > Będzie używał 2 kierunków na zmianę tylko wtedy, gdy jest na ich
> > granicy.
> > Efektywnie będzie wiec tworzył proste jedynie w 16 różnych kierunkach.
> >
>
> chyba sluszna uwaga raczej nie przemyslalem tego
>
> > Aby temu zapobiec, trzeba albo pamiętać linię, po której się porusza
> > (skomplikowane, niepotrebne i, a do tego jak się domyślam, że śledzony
> > punkt się porusza:) )
> > albo pamiętać ułamkową pozycję i robić ideowo jak u Bresenhama.
> >
> >
> > I teraz pytanie, co tak naprawdę robisz.
> >
> > Jeśli rysujesz linię,
> > - Użyj Bresenhama.
> > - Twoja biblioteka graficzna nie ma rysowania linii? Muis mieć. Niech
> > ona to zrobi, wtedy karta graficzna narysuje linię, nie procek;-)
> >
> > Jeśli jets to ludzik goniący za być możę ruchomym punktem,
> > idea jest ta sama (błąd-korekcja) - ludzik ma pozycję znaną
> > dokałdniej niż 'ten piksel'. Nie da się sprowadzić do wspolnego
> > mianownika jak dla stałej linii, więc albo float (najwygdniej) albo
> > 'stały przecinek', czyli np pozycja z to int z dokłądnosćią do 1/1024
> > piksela.
> >
>
> a masz jakis matematyczny/logiczny dowód
> ze tego sie nie da zrobic?
>
> dla mnie nie jest to takie pewne (nie mam zdania)
>
> tego co uzywam raczej uzywalbym do rysowania lini - taka forma jest bardziej
'ogolna' np latwo z tego zrobic rysowanie lini przerywanej, w dwu kolorach -- no i
mozna tez uogolnic na nielinie (ale przypadek o ktory pytam to rysowanie lini)
>
> moge przerobic na floaty ale troche szkoda ze nie kojarze poprawnej wersji
> na intach - ew mozna kombinowac z zapamietywaniem tego subpixelowego przesuniecia
jako wewnetrznej zmiennej statycznej - temat niby prosty a wymaga troche przemyslania
>
>
>
> > BTW, jesli to ludzik i pogoń, to tak, jak to opisałeś, ma jeszcze jedną
> > wadę. Ruch pionowy i poziomy jest wolniejszy niż po przekątnych
> > o sqrt(2).
> >
>
>
przykladowa wersja float

int MovePointTowards(float* x, float* y, float dest_x, float dest_y)
{
float nx = *x;
float ny = *y;

float dx = dest_x - nx;
float dy = dest_y - ny;

if(fabs(dx)<0.1 && fabs(dy)<0.1) return 0;

float sx = fsign(dx);
float sy = fsign(dy);


if(sx==0) ny += sy;
else if(sy==0) nx += sx;
else
if (dy<dx)
{
float m = fabs(dy/dx);

nx += sx;
ny += m*sy;
}
else
{
float m = fabs(dx/dy);

ny += sy;
nx += m*sx;
}

*x=nx;
*y=ny;
return 1;

}

void foo()
{


float x = 100;
float y = 100;

do SetPixel(x,y, 0xffffff);
while(MovePointTowards(&x, &y, 234, 337));

}

dziala pytanie o ile to jest wolniejsze i
o ile by bylo po maksymalnym wyoptymalizowaniu

inne pytanie co mozna tym np ciekawego narysowac