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?

do góry

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

pzdr
bartekltg

do góry

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
dokladnie?

do góry

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
> dokladnie?

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

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

do góry

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
> > dokladnie?
>
> 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);
>
> 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

teraz pytaine czy da sie to przepisac tak by generowalo porzadna linie (tez biorac za
helper tylko punkt docelowy) czy tez trzeba uzyc wersji na floatach

do góry

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.

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.

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

pzdr
bartekltg

do góry

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


> pzdr
> bartekltg

do góry

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

do góry

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

do góry

On 13.03.2017 15:46, fir wrote:

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


No to gdzie problem, żby zastosować algorytm gościa na B?
Żadnych floatów, tyle iteracji ile pikseli, same zalety.
To naprawdę dopieszczony algorytm.


pzdr
bartekltg

do góry