[Python]Linee a gradi plot

Linguaggi di programmazione: php, perl, python, C, bash e tutti gli altri.
Avatar utente
gila75
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 2642
Iscrizione: mercoledì 16 gennaio 2013, 17:28
Desktop: ubuntu-2d
Distribuzione: Ubuntu 12.04.2 LTS i686
Località: Airuno(Lecco)

Re: [Python]Linee a gradi plot

Messaggio da gila75 »

Esattamente Nuzzo, in autocad 30 gradi la linea andava dall'origine a dx, -30 il contrario a sx.
Oppure, 150 gradi andava dal punto a sx (ma sempre con inclinazione a 30°), perchè cambiavi quadrante, se non ricordo male.
Certo ragionando così puoi implementare uno strumento per costruire poligoni.
Ho cercato di modificare il codice in modo un po' più pytonico, ma secondo me è peggio, molto meno leggibile ... bho

Codice: Seleziona tutto

import math
import matplotlib.pyplot as plt


def ridimensionamento (lati):
	lato_minimo=min(lati)
	print (lato_minimo)
	lati[0]/=lato_minimo
	lati[1]/=lato_minimo
	lati[2]/=lato_minimo
	
def angolo_gamma(lati,angoli):
	angoli[2]=(( (lati[0]**2)+ (lati[1]**2) -(lati[2]**2)) / (2*lati[0]*lati[1]))
	angoli[2]=(math.acos(angoli[2]))* 180/3.1415
	
def angolo_alfa(lati,angoli):
	angoli[0]=(( (lati[1]**2)+ (lati[2]**2) -(lati[0]**2)) / (2*lati[1]*lati[2]))
	angoli[0]=(math.acos(angoli[0]))* 180/3.1415
	

def calcola_punti(punti_x,punti_y,lati, angoli):
	x1=(math.cos(angoli[1]*3.1415/180))*lati[2]+punti_x[0]
	y1=(math.sin(angoli[1]*3.14/180))*lati[2]+punti_y[0]
	punti_x.append(x1)
	punti_y.append(y1)
	
	x2=(math.cos(angoli[2]*3.1415/180))*lati[1]+punti_x[1]
	y2=punti_y[1]-(math.sin(angoli[2]*3.1415/180))*lati[1]
	punti_x.append(x2)
	punti_y.append(y2)
	punti_x.append(2.5)
	punti_y.append(1)
	

def disegna (punti_x,punti_y):
	plt.xlim(0,5) 
	plt.ylim(0,5)
	plt.plot(punti_x,punti_y) 
	plt.show() 





lati=[5,4,3] # in ordine a,b,c
angoli=[0,0,0] # in ordine alfa,beta, gamma
punti_x=[2.5]
punti_y=[1]
ridimensionamento(lati)
print(lati)
angolo_gamma(lati,angoli)
angolo_alfa(lati,angoli)
angoli[1]=180-(angoli[0]+angoli[2])
print(angoli)
calcola_punti(punti_x,punti_y,lati,angoli)
disegna(punti_x,punti_y)
Non ho implementato le eccezioni...se non può da messaggio d'errore a terminale...per ora lascio così
Avatar utente
gila75
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 2642
Iscrizione: mercoledì 16 gennaio 2013, 17:28
Desktop: ubuntu-2d
Distribuzione: Ubuntu 12.04.2 LTS i686
Località: Airuno(Lecco)

Re: [Python]Linee a gradi plot

Messaggio da gila75 »

Affidandosi ai quadranti della trigonometria, è possibile implementare un costruttore di poligoni, forse intendevi così @Nuzzo

Codice: Seleziona tutto

# costruttore poligoni
#cos+ sin+ (1° quad)
#cos- sin+ (2° quad)
#cos- sin- (3° quad)
#cos+ sin- (4° quad)
#-----------------------------------------


import math
import matplotlib.pyplot as plt

def costruisci_poligono(punti_x,punti_y):
	lati=8
	angolo_int=360/lati
	somma_angoli=angolo_int
	for i in range (lati):
		print(somma_angoli)
		punti_x.append (((math.cos(somma_angoli*math.pi/180)))+punti_x[-1])
		punti_y.append (((math.sin(somma_angoli*math.pi/180)))+punti_y[-1])
		somma_angoli+=angolo_int
		print ("x", punti_x)
		print ("y",punti_y)
	#-------DISEGNA-----------------------	
	plt.xlim(0, 5) 
	plt.ylim(0, 5)
	plt.plot(punti_x,punti_y) 
	plt.show() 

punti_x=[3.5]
punti_y=[0.5]
costruisci_poligono(punti_x,punti_y)


La cosa starna è che nel plot le x risultano più "lunghe" delle y. Qualcuno mi sa dire il perchè ?
Come vedete dall'immagine sembra più un rettangolo. E non credo che siano i calcoli, se notate i numeri in x e y si vede a occhio che sono
di diversa lunghezza...magari va regolato qualcosa
Allegati
quad.png
quad.png (7.54 KiB) Visualizzato 395 volte
Avatar utente
vaeVictis
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 4305
Iscrizione: venerdì 27 luglio 2012, 17:58
Desktop: Gnome
Distribuzione: Ubuntu 18.04.4 64bit

Re: [Python]Linee a gradi plot

Messaggio da vaeVictis »

Perché li ha disegnati con una scala diversa in modo da adattarli al contesto.
Cerca un metodo di nome set_aspect di plt, con il quale puoi impostare che abbiano la stessa scala.
Pirates arrrrrrrrrrr awesome!!!
«I fear not the man who has practiced 10000 kicks once, but I fear the man who has practiced one kick 10000 times.»
Avatar utente
gila75
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 2642
Iscrizione: mercoledì 16 gennaio 2013, 17:28
Desktop: ubuntu-2d
Distribuzione: Ubuntu 12.04.2 LTS i686
Località: Airuno(Lecco)

Re: [Python]Linee a gradi plot

Messaggio da gila75 »

Grazie @vae, provo

EDIT

ho usato

Codice: Seleziona tutto

plt.figure(figsize = (5,5))
e non ho più quell'effetto indesiderato. Il problema è che generava un plot dove l'asse x era maggiore dell'asse y
e di conseguenza adattava.
Ora va bene, ho altri problemucci, ma con calma si risolve.Ho trovato pochi esempi della funzione che mi suggerisci, ma sono di fretta magari per quello.
Avatar utente
nuzzopippo
Entusiasta Emergente
Entusiasta Emergente
Messaggi: 1413
Iscrizione: giovedì 12 ottobre 2006, 11:34

Re: [Python]Linee a gradi plot

Messaggio da nuzzopippo »

gila75 ha scritto:
venerdì 28 agosto 2020, 19:00
Affidandosi ai quadranti della trigonometria, è possibile implementare un costruttore di poligoni, forse intendevi così @Nuzzo
... non esattamente, riferivo sempre ai metodi polari, certamente più macchinosi dell'utilizzo diretto degli angoli interni del poligono, molto efficace la Tua codifica.

Per quanto riguarda la sproporzione tra gli assi x/y, prima di plt.show() inserisci un "plt.axis('equal')", dovrebbe essere sufficiente, almeno a me funzia.

riguardo ciò che volevo far io, era definire i vertici utilizzando le coordinate polari relative ai punti di vertice precedenti, inserendo anche un fattore di inclinazione, il tutto realizzato tramite classi, Te lo mostro nel caso Tu provi e ti senta invogliato a guardartele, proseguendo il discorso già postato, questa serie di classi (poste in un file che ho chiamato "polar_regular_poligon.py" definiscono gli oggetti:

Codice: Seleziona tutto

import math

class PlanePoint:
    '''
    Un punto nel piano.
    '''
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    
    def sum(self, p):
        '''
        Esegue la somma di due PanePoint.

        parametri : p - un PlanePoint

        return    : un PlanePoint
        '''
        return PlanePoint(self.x + p.x, self.y + p.y)
    
    def get_coords(self):
        '''
        restituisce la tupla delle coordinate.
        '''
        return self.x, self.y


class PolarSpace:
    '''
    Un offset da una "origine" definito tramite coordinate polari
    '''
    def __init__(self, length, angle):
        '''
        Definizione dell'offset polare

        parametri : length - lunghezza del segmento
                    angle  - angolazione del segmento, in sessaggesimali
        '''
        self.length = length
        self.angle = angle
    
    def get_relative_point(self):
        '''
        Restituisce le coordinate di spostamento.

        return : un PlanePoint
        '''
        x = self.length * math.cos(math.radians(self.angle))
        y = self.length * math.sin(math.radians(self.angle))
        return PlanePoint(x, y)

class PolarPoligon:
    '''
    Costruisce un poligono regolare con logica polare ad angoli sessagesimali.
    '''
    def __init__(self, n_l, l_length, incl=0.0):
        '''
        Inizializzazione elementi poligono.
        
        Parametri : n_l      : intero, numero di lati del poligono
                    l_length : intero, lunghezza di ogni lato
                    incl     : float, inclinazione della base del poligono
                               (lato n -> 0)
        '''
        if n_l < 3:
            raise RuntimeError('Numero lati insufficiente')
        self.n_elem = n_l
        internal_angle = 360 / self.n_elem
        self.v_angle = 180 - internal_angle  # angoli al vertice
        self.o_point = None  # punto iniziale delle coordinate polari
                             # se None è il punto iniziale (0,0 cartesiano)
        self.l_length = l_length
        self.inclination = incl
        
    def set_point(self, p):
        '''
        Stabilisce le coordinate cartesiane del 1° vertice.
        
        parametri : p : un PlanePoint
        
        nota : si tratta di una utilità per l'user, la classe esige una
               coordinata polare, procede, pertanto, a calcolarsi il
               PolarSpace iniziale ed acquisirlo quale proprietà di istanza
        '''
        if not p.x and not py:
            ps = PolarSpace(0, 0)
        elif not p.x and p.y:
            if p.y > 0:
                ps = PolarSpace(p.y, 90,0)
            else:
                ps = PolarSpace(p.y, 270.0)
        elif not p.y and p.x:
            if p.x > 0:
                ps = PolarSpace(p.x, 0.0)
            else:
                ps = PolarSpace(p.x, 180.0)
        else:
            ipo = math.sqrt(abs(p.x)**2 + abs(p.y)**2)
            abs_angle = math.degrees(math.atan2(abs(p.y), abs(p.x)))
            # determinna il quadrante del punto
            if p.x > 0:
                if p.y > 0:
                    quadr = 1
                else:
                    quadr = 4
            else:
                if p.y > 0:
                    quadr = 2
                else:
                    quadr = 3
            if quadr == 1:
                angle = abs_angle
            elif quadr == 2:
                angle = 180 - abs_angle
            elif quadr == 3:
                angle = 180 + abs_angle
            else:
                angle = 360 - abs_angle
            ps = PolarSpace(ipo, angle)
        self.set_polar_point(ps)
     
    def set_polar_point(self, ps):
        '''
        Imposta il punto polare di partenza.
        
        parametri : ps : un PolarSpace
        '''
        self.o_point = ps
        self._def_polar_vertex()
    
    def _def_polar_vertex(self):
        self.p_vertex_c = [self.o_point]
        c_angle = self.o_point.angle + self.inclination + self.v_angle
        for i in range(1, self.n_elem):
            p = PolarSpace(self.l_length, c_angle)
            self.p_vertex_c.append(p)
            c_angle = p.angle + 180 + self.v_angle
            if c_angle >= 360:
                c_angle = c_angle - 360
    
    def get_cartesian_coords(self):
        p = PlanePoint(0.0, 0.0)
        c_c = []
        for pp in self.p_vertex_c:
            p = p.sum(pp.get_relative_point())
            c_c.append(p.get_coords())
        c_c.append(self.o_point.get_relative_point().get_coords())
        return c_c
e questo è il codice di test, definito nella stessa direttrice per comodità

Codice: Seleziona tutto

import matplotlib.pyplot as plt
from polar_regular_poligon import *

if __name__ == '__main__':
    
    var = input('num. lati? : ')
    n_lati = int(var)
    var = input('lunghezza? : ')
    lung = int(var)
    var = input('inclinazione? : ')
    if var:
        incl = int(var)
    else:
        incl = 0
    
    pol = PolarPoligon(n_lati, lung, incl)
    p = PlanePoint(1, 0)
    pol.set_point(p)
    coord = pol.get_cartesian_coords()
    xs = [v[0] for v in coord]
    ys = [v[1] for v in coord]
    #print(pol.get_cartesian_coords())
    plt.plot(xs, ys)
    plt.axis('equal')
    plt.show()
con detti oggetti, possono ottenersi le coordinate cartesiane dei vertici di un poligono regolare con lati da tre in su a piacere, con posizione iniziale ed inclinazione della base, rispetto all'asse "X" definiti a piacere da parte dell'utente. La posizione iniziale può essere definita, sempre a piacere, tramite coordinate polari o cartesiane.
Noterai che la parte "elaborazione dati" è avulsa dal contesto di visualizzazione, pertanto può essere utilizzata in un generico contesto di view.
Fatti non foste a viver come bruti ...
Avatar utente
gila75
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 2642
Iscrizione: mercoledì 16 gennaio 2013, 17:28
Desktop: ubuntu-2d
Distribuzione: Ubuntu 12.04.2 LTS i686
Località: Airuno(Lecco)

Re: [Python]Linee a gradi plot

Messaggio da gila75 »

@Nuzzo, sarò di testa dura, ma ancora non capisco bene la differenza.
dati x,y di partenza, gradi linea e lunghezza, non conosco altro modo (per mia ignoranza) oltre a quello postato.
Comunque provo a rileggere bene e a lanciare il programma si sa mai che mi rimetto a studiare python.
Grazie per le dritte sul plot, provo anche quelle

Edit

qui spiega le differenze , molto interessante, me lo studio e cerco di capire

https://it.wikipedia.org/wiki/Sistema_d ... ate_polari
Avatar utente
gila75
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 2642
Iscrizione: mercoledì 16 gennaio 2013, 17:28
Desktop: ubuntu-2d
Distribuzione: Ubuntu 12.04.2 LTS i686
Località: Airuno(Lecco)

Re: [Python]Linee a gradi plot

Messaggio da gila75 »

@vae
Le coordinate polari sono comprensibili anche se non si ha una formazione matematica :)

Con le coordinate cartesiane individui un punto nel piano con le due coordinate x e y.

Con le coordinate polari individui un punto P nel piano con le due coordinate date da:
1) lunghezza del segmento OP che congiunge l'origine con il punto P
2) angolo che il suddetto segmento forma con l'asse delle ascisse (l'asse delle x)
non capisco vae, ma rileggendo, non è in fondo quello che ho fatto ?
ho un punto di origine (P), lunghezza segmento OP e angolo, e individuo x,y, dove il segmento OP finisce.
Credo che sia quello che ho fatto.
Scusami se non capisco, sarà che ho ricominciato a lavorare e sono un po' stanco :D
Evidentemente mi sfugge qualcosa...
Oppure le polari differiscono così: ho un punto di origine (p) lunghezza OP e gradi.
io con lunghezza x e gradi alfa ho solo un punto dove posso arrivare, così posso indicare un punto (rispetto ad un origine) solo con
lunghezza e gradi, giusto ?
Allegati
CircularCoordinates.png
CircularCoordinates.png (5.13 KiB) Visualizzato 288 volte
Avatar utente
vaeVictis
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 4305
Iscrizione: venerdì 27 luglio 2012, 17:58
Desktop: Gnome
Distribuzione: Ubuntu 18.04.4 64bit

Re: [Python]Linee a gradi plot

Messaggio da vaeVictis »

Io il codice non l'ho letto, scusami, quindi non saprei dirti se hai fatto così.

Comunque queste sono coordinate polari sul piano. L è l'asse delle x e O (non P) è l'origine.
Le coordinate che individuano un generico punto sono la r e theta.
Pirates arrrrrrrrrrr awesome!!!
«I fear not the man who has practiced 10000 kicks once, but I fear the man who has practiced one kick 10000 times.»
Avatar utente
gila75
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 2642
Iscrizione: mercoledì 16 gennaio 2013, 17:28
Desktop: ubuntu-2d
Distribuzione: Ubuntu 12.04.2 LTS i686
Località: Airuno(Lecco)

Re: [Python]Linee a gradi plot

Messaggio da gila75 »

vaeVictis ha scritto:
martedì 1 settembre 2020, 20:09
Io il codice non l'ho letto, scusami, quindi non saprei dirti se hai fatto così.

Comunque queste sono coordinate polari sul piano. L è l'asse delle x e O (non P) è l'origine.
Le coordinate che individuano un generico punto sono la r e theta.
si vae, ho fatto proprio così. L'immagine che ho postato dice che il segmento con lunghezza 3 e angolo 60 partendo da O, ha quella direzione,
ma non dice dove termina in x e y. Quindi sono ricorso alla trigonometria. davvero mi sfugge qualcosa, ma va bhè sono io che non capisco e non vorrei
risultare pesante
Avatar utente
vaeVictis
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 4305
Iscrizione: venerdì 27 luglio 2012, 17:58
Desktop: Gnome
Distribuzione: Ubuntu 18.04.4 64bit

Re: [Python]Linee a gradi plot

Messaggio da vaeVictis »

Non sei pesante. Siamo appositamente su un forum di supporto
Non ho capito cosa non ti è chiaro. Appena ho modo leggo il codice
Pirates arrrrrrrrrrr awesome!!!
«I fear not the man who has practiced 10000 kicks once, but I fear the man who has practiced one kick 10000 times.»
Avatar utente
nuzzopippo
Entusiasta Emergente
Entusiasta Emergente
Messaggi: 1413
Iscrizione: giovedì 12 ottobre 2006, 11:34

Re: [Python]Linee a gradi plot

Messaggio da nuzzopippo »

gila75 ha scritto:
giovedì 3 settembre 2020, 19:51
... si vae, ho fatto proprio così. L'immagine che ho postato dice che il segmento con lunghezza 3 e angolo 60 partendo da O, ha quella direzione,
ma non dice dove termina in x e y. Quindi ...
Mi sembra, @Gila, che Tu pensi ai due sistemi di coordinate come se fossero tra loro correlati, non è così, sono due sistemi "diversi" con scopi diversi, anche se è semplice relazionarli.
Certo, entrambi rappresentano dei punti, nel piano od anche nello spazio, ma mentre nel sistema "cartesiano" vengono rappresentati tramite due assi ortogonali tra loro, convenzionalmente X e Y, in base alle loro ordinate rispetto al punto di incontro degli assi, il sistema "polare" definisce il punto tramite la "distanza" da un determinato punto di origine e la "direzione" (ossi lo "angolo") che il punto ha rispetto ad una direzione di riferimento, convenzionalmente misurato in senso sinistrorso.

Ti ho già descritto prima un uso "tecnico" delle coordinate polari, sono utili nei rilievi con strumenti ottici dotati di un buon nonio, le coordinate cartesiane sono, invece, insostituibili nel rappresentare una serie precisa di "caselle", tipo i pixel del monitor o i punti di stampa.

Da un tipo si può passare tranquillamente all'altro utilizzando la matematica, tipicamente con i metodi trigonometrici dei triangoli, ma rimangono in ogni caso sistemi "diversi" per la identificazione di punti.
... Tieni presente che in un sistema polare tutti i punti devono riferirsi allo stesso punto di origine, dico ciò caso mai Ti ha confuso l'esempio di classi da me fatto, ove uso si metodi polari ma per coordinate relative (cioè riferite al punto precedente nella serie).
:ciao:
Fatti non foste a viver come bruti ...
Avatar utente
gila75
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 2642
Iscrizione: mercoledì 16 gennaio 2013, 17:28
Desktop: ubuntu-2d
Distribuzione: Ubuntu 12.04.2 LTS i686
Località: Airuno(Lecco)

Re: [Python]Linee a gradi plot

Messaggio da gila75 »

Innanzi tutto grazie della spiegazione.
Vediamo se ho capito:
Sistema polare: da come ho capito ti indica con gradi e lunghezza la "direzione"
Supponiamo nella navigazione, ho l'origine a Genova, con le coordinate polari (dati indicativi) di 500km gradi 270 individuo Cagliari.
Ma non so in x,y(in questo caso latitudine e longitudine) dove è di preciso Cagliari.
Sempre Genova, con km300 gradi 0 individuo Milano. Gradi 0 o 360 o 720, non cambia nulla se non erro.
In poche parole non ti specifica x,y. Ti dice solo: da qui (origine) con lunghezza y e gradi alfa "vai" in quella direzione per tot lunghezza.

Sistema cartesiano con x,y. Origine O, gradi alfa e lunghezza x, posso individuare dove la linea termina.
cos(alfa)*L=x
sin(alfa)*L=y

Logicamente dal cartesiano posso passare al polare: se io so che l'origine è (a caso) è 0,0 e la fine 10,10 , posso ricavare i 2 cateti
del triangolo rettangolo che si viene a formare, uso Pitagora per trovare l'ipotenusa e poi la trigonometria per trovare i due angoli
(uno è scontato che è a 90°)
Riassumendo come dicevi tu Nuzzo, sono impieghi diversi.
Io ho usato la trigonometria e il sistema cartesiano per "comporre" poligoni, forse il polare è più adatto alla navigazione e altro.
Se sono a Genova, non m'interessa molto dove è Cagliari in x e y. So che devo andare per 500 km a gradi 270.
Viceversa se so x,y di Cagliari e x,y di Genova, posso risalire al polare appunto come descritto prima con Pitagora+trigonometria.
Corretto ciò che dico ?
Avatar utente
nuzzopippo
Entusiasta Emergente
Entusiasta Emergente
Messaggi: 1413
Iscrizione: giovedì 12 ottobre 2006, 11:34

Re: [Python]Linee a gradi plot

Messaggio da nuzzopippo »

Si, in linea di massima il concetto è quello, anche se l'esempio "navigazione marittima" applicato, è in realtà, un pochino più complesso, dato che muovendosi sulla superficie terrestre si percorre, in realtà, la superficie di una approssimativa sfera e le linee sono in realtà degli archi.

Quando parliamo di "sistemi" applicati alla realtà, in generale, stiamo applicando degli schemi descriventi "approssimativamente" la realtà, per quanto riguarda il sistema di coordinate cartesiano abbiamo una miriade di piccoli utilizzi quotidiani, pensa allo "scrivere ordinatamente" su di un foglio a quadretti o a visualizzazioni video o stampe, di uso comune.
Altri campi di utilizzo del sistema polare possono essere, p.e., lo studio della composizione delle forze (vettori) od anche la grafica vettoriale, ove le immagini non perdono di definizione aumentando la risoluzione, contrariamente alle bitmap (che utilizzano sistemi di tipo cartesiano).
Sostanzialmente, sono entrambi degli "schemi" logici da applicarsi quando opportuno, secondo le circostanze ed il risultato voluto.
È giusto quanto dici circa il "risalire al polare", i due sistemi si convertono tra loro con facilità.

Volendo marcare delle differenze tra il Tuo sistema "cartesiano" per la composizione di poligoni ed il mio sistema "polare", che di fatto è un modello vettoriale, considera la "inclinazione" del poligono impostabile nella mia rappresentazione : implementarla è fattibile anche con metodologie puramente cartesiane ma con una più consistente quantità di calcoli.
Per altro, tornando al codice, ed è questo che volevo mostrarti con le classi del mio esempio, sono gli oggetti elementari "PolarSpace" e "PlanePoint" ad effettuare i "calcoli" necessari ad ottenere le coordinate (cartesiane) di visualizzazione, di per se "PolarPoligon" non fa altro che definire il giusto angolo ed instanziare l'opportuno PolarSpace.
Fatti non foste a viver come bruti ...
Avatar utente
gila75
Imperturbabile Insigne
Imperturbabile Insigne
Messaggi: 2642
Iscrizione: mercoledì 16 gennaio 2013, 17:28
Desktop: ubuntu-2d
Distribuzione: Ubuntu 12.04.2 LTS i686
Località: Airuno(Lecco)

Re: [Python]Linee a gradi plot

Messaggio da gila75 »

Grazie @Nuzzo, ok, allora più o meno ho capito. Ho cercato di fare esempi (navigazione) magari un po' forzati, solo per intenderci
Volendo marcare delle differenze tra il Tuo sistema "cartesiano" per la composizione di poligoni ed il mio sistema "polare", che di fatto è un modello vettoriale, considera la "inclinazione" del poligono impostabile nella mia rappresentazione : implementarla è fattibile anche con metodologie puramente cartesiane ma con una più consistente quantità di calcoli.
Per altro, tornando al codice, ed è questo che volevo mostrarti con le classi del mio esempio, sono gli oggetti elementari "PolarSpace" e "PlanePoint" ad effettuare i "calcoli" necessari ad ottenere le coordinate (cartesiane) di visualizzazione, di per se "PolarPoligon" non fa altro che definire il giusto angolo ed instanziare l'opportuno PolarSpace.
Qui, devo approfondire, non ho ancora provato il tuo codice ad oggetti. Appena finisce la bella stagione, che sto sfruttando per andare in bici, vorrei ricominciare lo studio.
Domani se riesco provo a lanciare il tuo codice e cercare di capire per lo meno i concetti. Le classi, oggetti ecc, purtroppo ora come ora non so nulla
Scrivi risposta

Ritorna a “Programmazione”

Chi c’è in linea

Visualizzano questa sezione: 0 utenti iscritti e 1 ospite