W dniu poniedziałek, 13 marca 2017 17:09:32 UTC+1 użytkownik fir napisał:
> 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)

powinno byc if(fabs(dy)<fabs(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