Non sovrascrivere i vecchi post, che non si capisce nulla
Così compila - te lo divido in due parti perché c'è il limite di caratteri
Parte 1
//Librerie
#include <cstdlib>
#include <cstdio>
#include <iostream>
#define _USE_MATH_DEFINES
#include <cmath>
#include <cstring>
//Costanti
#define M_PI 3.1415926535897932384626433832795028841971694
//Dichiarazione degli spazi di lavoro
using namespace std;
//Dichiarazione dei records:
typedef struct punto {
double asc;//Ascissa del punto
double ord;//Ordinata del punto
} Tpunto;
typedef struct pianoCartesiano {
bool vista;//False: XY o YZ; True: XZ
Tpunto O;//Coordinate dell'origine del piano attivo, rispetto all'origine assoluto
} TpianoCartesiano;
typedef struct circonferenza {
Tpunto centro;//Coordinate del centro
double raggio;//Raggio
double eq[5];//Equazione implicita della circonferenza: eq[4]=x^2 + eq[3]=y^2 + eq[2]=ax + eq[1]=by + eq[0]=c = 0;
} Tcirconferenza;
//Dichiarazione dei prototipi di funzione:
void azzeraVettore(short int lengthVettore, double* array);//Equivalente al pgm della Star O6020
double radianti(double gradi);
double gradi(double radianti);
double teoremaPitagora(bool ipotenusa_cateto, double a, double b);//Equivalente al pgm della Star O6000
double gradiTraDueLatiPoligono(short int numeroLatiPoligono);//Equivalente al pgm della Star O6001
double lunghezzaIpotenusaDaGradi_catetOrizzontale(double gradi, double misuraCatetOrizzontale);//Equivalente al pgm della Star O6002
double lunghezzaCatetoVerticaleDaGradiEipotenusa(double gradi, double misuraIpotenusa);//Equivalente al pgm della Star O6003
double lunghezzaCatetOrizzontaleDaGradiEipotenusa(double gradi, double misuraIpotenusa);//Equivalente al pgm della Star O6004
double gradiDaCoordinatePunto(bool pianoVista, double* coordinatePunto);//Equivalente al pgm della Star O6005
void duplicPolarPoint(bool pianoVista, Tpunto piano, Tpunto p, bool tieniPuntoRiferimento, double gradi, short int numPunti, Tpunto* punti);//Equivalente al pgm della Star O6006
void fascioRetta(bool pianoVista, double* datiRetta, double* eq_FascioDiRette);//Equivalente al pgm della Star O6007
void rettaDuePunti(double* coordinatePunti, double* eq_Retta);//Equivalente al pgm della Star O6008
void intersezioneRette(double* eq_primaRetta, double* eq_secondaRetta, Tpunto& p);//Equivalente al pgm della Star O6009
void circonferenza(double* datiCirconferenza, double* equazioneCirconferenza);//Equivalente al pgm della Star O6010
void conica(double* datiConica, double* equazione);//Equivalente al pgm della Star O6011
void formulaEq_2(double* equazioneSecondoGrado, double* soluzioni);//Equivalente al pgm della Star O6012
void asseRadicaleTraCirconferenze(double* equazioneC1, double* equazioneC2, double* equazioneRetta);//Equivalente al pgm della Star O6013
void sistemaCirconferenzaRetta(double* equazioneCirconferenza, double* equazioneRetta, double* coordinate);//Equivalente al pgm della Star O6014
double estrazioneCoordinataEquazioneRetta(double* eqRetta, bool selezionaIncognitaDesiderata, double valoreIncognitaNota);//Equivalente al pgm della Star O6015
double stabilizzaAngolo(double gradiAngolo);//Equivalente al pgm della Star O6016
void eqPuntoSuCirconf(Tpunto p, double* eq);//Equivalente al pgm della Star O60
void eqRaggioCirconf(double raggio, double* eq);//Equivalente al pgm della Star O60
void fattorizzaEquazione(short int lengthEquaz, short int numIndFat, double* eq);//Equivalente al pgm della Star O60
void prod_Coeff_Polinomio(double coefficiente, short int lengthPol, double* pol, double* prodotto);//Equivalente al pgm della Star O60
void sqrBinomio(double binomio[2], double* quadratoBinomio);//Equivalente al pgm della Star O60
void sommaTraArrayOmogenei(short int lengthArray, double* array1, double* array2);//Equivalente al pgm della Star O60
void compattaArray(short int indicePartenza, short int numFinale, double* array);//Equivalente al pgm della Star O60
void ordinaArrayPerStep(short int step, short int lengthArrayOutput, double* arrayInput, double* arrayOutput);//Equivalente al pgm della Star O60
void centriCirPerDuePunti_Raggio(Tpunto* p, Tcirconferenza* circonf1, Tcirconferenza* circonf2);//Equivalente al pgm della Star O60
void polarizzaPunto(bool pianoVista, double* coordinate, double angolo, short int numeroPunti, double* coordinatePolarizzate);
void creaGeometriaDaPunti(bool pianoVista, bool sensoPolare, bool esistenzaRaccordo, double* coordinatePuntiIniziali, short int numeroCopiePunti, double gradiIncrementali, double* geometria);
//FUNZIONI GENERICHE
/*Funzione che azzera gli elementi del vettore inserito.
short int lengthVettore = lunghezza del vettore (numero intero nominale);
double* array = vettore da azzerare.*/
void azzeraVettore(short int lengthVettore, double* array) {
for (short int i = 0; i < lengthVettore; i++)
array[i] = 0.0;
}
//TRIGONOMETRIA
//Funzione--> che trasforma i gradi in radianti
double radianti(double gradi) {
return gradi * (M_PI / 180.0);
}
//Funzione--> che trasforma i radianti in gradi
double gradi(double radianti) {
return radianti * (180.0 / M_PI);
}
//Geometria Piana
/*Funzione che calcola la lunghezza dell'ipotenusa o di un cateto di un triangolo rettangolo in base opzione scelta.*/
double teoremaPitagora(bool ipotenusa_cateto, double a, double b) {
if (ipotenusa_cateto == true)
return sqrt(pow(a, 2) + pow(b, 2));
else
return sqrt(pow(a, 2) - pow(b, 2));
}
/*Funzione che restituisce la misura in gradi dell'angolo formato allo spigolo tra due lati di un poligono regolare.*/
double gradiTraDueLatiPoligono(short int numeroLatiPoligono) {
return 180.0 - (360.0 / numeroLatiPoligono);
}
/*Funzione--> che restituisce la lunghezza dell'ipotenusa di un triangolo rettangolo conoscendo angolo (in gradi)
e misura di un cateto (orizzontale o coseno dell'angolo inserito).*/
double lunghezzaIpotenusaDaGradi_catetOrizzontale(double gradi, double misuraCatetOrizzontale) {
return misuraCatetOrizzontale / cos(radianti(gradi));
}
/*Funzione--> che restituisce la lunghezza del cateto verticale di un triangolo rettangolo conoscendo l'angolo (in gradi)
e la misura dell'ipotenusa.*/
double lunghezzaCatetoVerticaleDaGradiEipotenusa(double gradi, double misuraIpotenusa) {
return misuraIpotenusa * sin(radianti(gradi));
}
/*Funzione--> che restituisce la lunghezza del cateto verticale di un triangolo rettangolo conoscendo l'angolo (in gradi)
e la misura dell'ipotenusa.*/
double lunghezzaCatetOrizzontaleDaGradiEipotenusa(double gradi, double misuraIpotenusa) {
return misuraIpotenusa * cos(radianti(gradi));
}
/*Funzione che restituisce i gradi rispetto all'asse delle ascisse della retta passante per l'origine ed un punto dato.*/
double gradiDaCoordinatePunto(bool pianoVista, double* coordinatePunto) {
//Dichiarazione delle variabili locali
double gradiAngolo = 0;
/*Elaborazione*/
if (coordinatePunto[0] != 0) {
gradiAngolo = gradi(atan(coordinatePunto[1] / coordinatePunto[0]));//Calcolo dell'angolo formato dalla retta origine/punto con l'ascissa
if (pianoVista == false)
if (coordinatePunto[0] > 0)
if (coordinatePunto[1] >= 0)
return gradiAngolo;
else
return 360.0 + gradiAngolo;
else
return 180.0 + gradiAngolo;
else
if (coordinatePunto[0] > 0)
return 90.0 - gradiAngolo;
else
return 270.0 - gradiAngolo;
}
else
if (pianoVista == false)
if (coordinatePunto[1] > 0)
return 90.0;
else
return 270.0;
else
if (coordinatePunto[1] > 0)
return 0;
else
return 180.0;
}
/*Funzione che duplica polarmente un punto iniziale, restituendo in un array le coordinate di tali punti.
- pianoVista = indica il piano su cui si vuole duplicare il punto:
pianoVista = 0-->XY e YZ;
pianoVista = 1-->XZ.
- piano = coordinate del piano cartesiano attivo:
-piano.asc: ascissa;
-piano.ord: ordinata.
- p = coordinate del punto di riferimento da duplicare:
-p.asc: ascissa;
-p.ord: ordinata.
- tieniPuntoRiferimento = true tiene all'indice zero le coordinate del punto di riferimento.
- gradi = angolo di duplicazione attorno all'origine [in gradi].
- numPunti = numero di copie dei punti desiderati.
- punti = vettore di output che contiene le coordinate polari dei punti duplicati:
punti[].asc = ascissa;
punti[].ord = ordinata.*/
void duplicPolarPoint(bool pianoVista, Tpunto piano, Tpunto p, bool tieniPuntoRiferimento, double gradi, short int numPunti, Tpunto* punti) {
short int contPosPunto = 1;
double distOrig = 0.0;//Assume la distanza dall'origine del punto di input
double teta = 0.0;
//Elaborazione
gradi = radianti(gradi);
distOrig = teoremaPitagora(true, p.asc, p.ord);//Calcolo della distanza del punto dall'origine
//Calcolo dell'angolo, della retta passante per l'origine ed il punto iniziale con l'asse delle ascisse
if (p.asc == 0.0)
if (pianoVista == false)
if (p.ord > 0.0)
teta = M_PI * 0.5;//90°
else
teta = M_PI * 1.5;//270°
else
if (p.ord > 0.0)
teta = 0.0;//0°
else
teta = M_PI;//180°
else {
teta = p.ord / p.asc;//Calcolo dell'angolo che forma la retta Origine/Punto rispetto all'ascissa
teta = atan(teta);
if (pianoVista == false) {
if (p.asc < 0.0)
teta = M_PI + teta;//180°+teta
}
else
if (p.asc > 0.0)
teta = (M_PI * 0.5) - teta;//90°-teta
else
teta = (M_PI * 1.5) - teta;//270°-teta
}
//Calcolo delle coordinate dei punti duplicati polarmente
for (short int i = 0; i < numPunti; i++)
if (tieniPuntoRiferimento == true && i == 0) {
//Le coordinate del primo punto del vettore sono quelle del punto inserito
punti[i].asc = p.asc;
punti[i].ord = p.ord;
numPunti++;
}
else {
gradi *= double(contPosPunto);
gradi += teta;//Incremento dell'angolo teta dell'angolo inserito
//Calcolo delle coordinate dei punti duplicati polarmente
if (pianoVista == false) {
punti[i].asc = distOrig * cos(gradi);
punti[i].ord = distOrig * sin(gradi);
}
else {
punti[i].asc = distOrig * sin(gradi);
punti[i].ord = distOrig * cos(gradi);
}
if (fabs(punti[i].asc) <= 0.0001)
punti[i].asc = 0.0;
if (fabs(punti[i].ord) <= 0.0001)
punti[i].ord = 0.0;
gradi -= teta;//Decremento dell'angolo teta dell'angolo inserito
gradi /= double(contPosPunto);//Ripristino dell'angolo iniziale
contPosPunto++;//Incremento della posizione punto
}
//Traslazione dei punti rispetto al piano cartesiano attivo
for (short int i = 0; i <= numPunti; i++) {
punti[i].asc += piano.asc;
punti[i].ord += piano.ord;
}
}
//ANALISI MATEMATICA
/*Funzione che restituisce i 3 coefficienti dell'equazione di una retta passante per un punto usando l'equazione del fascio di rette per un punto: y - y0 = m (x - x0).*/
void fascioRetta(bool pianoVista, double* datiRetta, double* eq_FascioDiRette) {
double supportoDatiRetta[3] = {};
for (short int i = 0; i < 3; i++)
supportoDatiRetta[i] = datiRetta[i];//Assegno a supportoRetta i dati della retta
//Condizione in cui viene verificato il piano su cui giace la retta
if (pianoVista == true)
supportoDatiRetta[2] = 90.0 - supportoDatiRetta[2];
//Calcolo dei coefficienti della retta rispetto alle varie condizioni possibili
if (supportoDatiRetta[2] == 0 ||
supportoDatiRetta[2] == 180.0 ||
supportoDatiRetta[2] == 360.0 ||
supportoDatiRetta[2] == -180.0 ||
supportoDatiRetta[2] == -360.0) {
eq_FascioDiRette[1] = supportoDatiRetta[1];
eq_FascioDiRette[2] = 0;
eq_FascioDiRette[0] = 0;
}
else if (supportoDatiRetta[2] == 90.0 ||
supportoDatiRetta[2] == 270.0 ||
supportoDatiRetta[2] == -90.0 ||
supportoDatiRetta[2] == -270.0) {
eq_FascioDiRette[1] = 0;
eq_FascioDiRette[2] = supportoDatiRetta[0];
eq_FascioDiRette[0] = 0;
}
else {
eq_FascioDiRette[1] = 1;
eq_FascioDiRette[2] = tan(radianti(supportoDatiRetta[2]));
eq_FascioDiRette[0] = supportoDatiRetta[1] - (eq_FascioDiRette[2] * supportoDatiRetta[0]);
if (eq_FascioDiRette[0] <= 0.0001 && eq_FascioDiRette[0] >= -0.0001)
eq_FascioDiRette[0] = 0;
}
}
/*Funzione che restituisce i 3 coefficienti dell'equazione di una retta passante per due punti usando la relativa equazione : [(y - y1) / (y2 - y1)] = [(x - x1) / (x2 - x1)].*/
void rettaDuePunti(double* coordinatePunti, double* eq_Retta) {
//Dichiarazione delle variabili locali
double denominatoreOrdinata = 0;
double denominatoreAscissa = 0;
if (coordinatePunti[1] == coordinatePunti[3]) {
denominatoreOrdinata = 0;
denominatoreAscissa = 1;
}
else if (coordinatePunti[0] == coordinatePunti[2]) {
denominatoreOrdinata = 1;
denominatoreAscissa = 0;
}
else {
denominatoreOrdinata = coordinatePunti[3] - coordinatePunti[1];
denominatoreAscissa = coordinatePunti[2] - coordinatePunti[0];
}
if (denominatoreOrdinata == 0) {
eq_Retta[1] = coordinatePunti[1];
eq_Retta[2] = 0;
eq_Retta[0] = 0;
}
else if (denominatoreAscissa == 0) {
eq_Retta[1] = 0;
eq_Retta[2] = coordinatePunti[0];
eq_Retta[0] = 0;
}
else {
eq_Retta[1] = 1;
eq_Retta[2] = denominatoreOrdinata / denominatoreAscissa;
eq_Retta[0] = ((denominatoreAscissa * coordinatePunti[1]) - (denominatoreOrdinata * coordinatePunti[0])) / denominatoreAscissa;
}
}
/*Funzione--> che restituisce le coordinate del punto d'incidenza tra due rette, usando il sistema tra rette ed utilizzando il metodo di sostituzione.*/
void intersezioneRette(double* eq_primaRetta, double* eq_secondaRetta, Tpunto& p) {
//Dichiarazione delle variabili locali
double m = 0, q = 0;
//Elaborazione
if ((eq_primaRetta[2] == 0 && eq_primaRetta[0] == 0) || (eq_secondaRetta[2] == 0 && eq_secondaRetta[0] == 0)) {//Caso in cui la retta è orizzontale quindi la m=0°
if (eq_primaRetta[2] == 0) {
p.ord = eq_primaRetta[1];
m = eq_secondaRetta[2];
q = eq_secondaRetta[0];
}
else {
p.ord = eq_secondaRetta[1];
m = eq_primaRetta[2];
q = eq_primaRetta[0];
}
p.asc = (p.ord - q) / m;
}
else {
if ((eq_primaRetta[1] == 0 && eq_primaRetta[0] == 0) || (eq_secondaRetta[1] == 0 && eq_secondaRetta[0] == 0))//Caso in cui la retta è verticale quindi la m=90°
if (eq_primaRetta[1] == 0) {
m = eq_secondaRetta[2];
p.asc = eq_primaRetta[2];
q = eq_secondaRetta[0];
}
else {
m = eq_primaRetta[2];
p.asc = eq_secondaRetta[2];
q = eq_primaRetta[0];
}
else {//Caso in cui la retta ha un angolo diverso da 0° e 90°
m = eq_primaRetta[2];
q = eq_primaRetta[0];
p.asc = (eq_primaRetta[0] - eq_secondaRetta[0]) / (eq_secondaRetta[2] - eq_primaRetta[2]);
}
p.ord = (m * p.asc) + q;
}
if (fabs(p.asc) <= 0.0001)
p.asc = 0.0;
if (abs(p.ord) <= 0.0001)
p.ord = 0.0;
}
/*Funzione--> che restituisce in un vettore i coefficienti dell'equazione di una circonferenza.*/
void circonferenza(double* datiCirconferenza, double* equazioneCirconferenza) {
equazioneCirconferenza[0] = pow(datiCirconferenza[0], 2) + pow(datiCirconferenza[1], 2) - pow(datiCirconferenza[2], 2);//Valore noto senza incognita
equazioneCirconferenza[1] = (-2.0) * datiCirconferenza[1];//Coefficiente di y
equazioneCirconferenza[2] = (-2.0) * datiCirconferenza[0];//Coefficiente di x
equazioneCirconferenza[3] = 1.0;//Coefficiente di y^2
equazioneCirconferenza[4] = 1.0;//Coefficiente di x^2
}
/*Funzione che restituisce i termini dell'equazione di 2° grado di una figura conica.*/
void conica(double* datiConica, double* equazione) {
//Dichiarazione delle variabili locali
double fattorizzatore = 0;
//Elaborazione
equazione[4] = pow(datiConica[3], 2);//x^2
equazione[3] = pow(datiConica[2], 2);//y^2
equazione[2] = (-2.0) * datiConica[0] * equazione[4];//x
equazione[1] = (-2.0) * datiConica[1] * equazione[3];//y
equazione[0] = (pow(datiConica[0], 2) * equazione[4]) + (pow(datiConica[1], 2) * equazione[3]) - (equazione[4] * equazione[3]);//termine noto
fattorizzatore = equazione[3];//Assegno a questa variabile il coefficiente di y^2 per poter fattorizzare l'equazione successivamente
for (short int i = 4; i >= 0; i--)
equazione[i] /= fattorizzatore;//Fattorizzazione dell'equazione della conica
}
/*Funzione che restituisce in un vettore le eventuali soluzioni di un'eqauzione di secondo grado passata alla funzione.*/
void formulaEq_2(double* equazioneSecondoGrado, double* soluzioni) {
double supportoEquazioneSecondoGrado[3] = {};//Conterrà i valori dell'equazione di secondo grado passata
double delta = 0;
for (short int i = 2; i >= 0; i--)
supportoEquazioneSecondoGrado[i] = equazioneSecondoGrado[i];
delta = pow(supportoEquazioneSecondoGrado[1], 2) - (4.0 * supportoEquazioneSecondoGrado[2] * supportoEquazioneSecondoGrado[0]);
if (fabs(delta) <= 0.0001) {
soluzioni[0] = (-supportoEquazioneSecondoGrado[1]) / (2.0 * supportoEquazioneSecondoGrado[2]);
soluzioni[1] = soluzioni[0];
}
else {
soluzioni[0] = ((-supportoEquazioneSecondoGrado[1]) + sqrt(delta)) / (2.0 * supportoEquazioneSecondoGrado[2]);
soluzioni[1] = ((-supportoEquazioneSecondoGrado[1]) - sqrt(delta)) / (2.0 * supportoEquazioneSecondoGrado[2]);
}
if (fabs(soluzioni[0]) <= 0.0001)
soluzioni[0] = 0.0;
if (fabs(soluzioni[1]) <= 0.0001)
soluzioni[1] = 0.0;
}
/*Restituisce in un vettore l'equazione dell'asse radicale formato da due circonferenze incidenti.*/
void asseRadicaleTraCirconferenze(double* equazioneC1, double* equazioneC2, double* equazioneRetta) {
//Dichiarazione delle variabili locali
double supportoEqCirc[5] = {};
short int i = 0;
//Assegnazione dei coefficienti dell'equazione C1 al vettore locale
for (i = 0; i <= 4; i++)
supportoEqCirc[i] = equazioneC1[i];
//Sottrazione tra i coefficienti delle equazioni di C1 e C2
for (i = 0; i <= 4; i++)
supportoEqCirc[i] -= equazioneC2[i];
//Calcolo dell'equazione della retta asse radicale
if (supportoEqCirc[1] == 0.0) {
equazioneRetta[2] = (-supportoEqCirc[0]) / supportoEqCirc[2];//Calcolo dell'incognita x
equazioneRetta[0] = 0.0;//Assegnazione del valore 0 al termine noto dell'equazione retta
equazioneRetta[1] = 0.0;//Assegnazione del valore 0 all'incognita y dell'equazione retta
}
else {
for (i = 0; i <= 2; i += 2) {
equazioneRetta[i] = -supportoEqCirc[i];//Cambio di segno del coefficiente di x e del termine noto
equazioneRetta[i] /= supportoEqCirc[1];//Fattorizzazione del coefficiente di x e del termine noto col coefficiente di y
}
equazioneRetta[1] = 1.0;//Assegnazione del valore 1 all'incognita y dell'equazione retta
}
}
/*Funzione--> che restituisce in un vettore le coordinate dei punti d'intersezione tra una circonferenza ed una retta.*/
void sistemaCirconferenzaRetta(double* equazioneCirconferenza, double* equazioneRetta, double* coordinate) {
//Dichiarazione delle variabili locali
double supportoCirconferenza[5] = {};//Si assegneranno a questo vettore i valori contenuti nell'array equazioneCirconferenza
double supportoRetta[3] = {};//Si assegneranno a questo vettore i valori contenuti nell'array equazioneRetta
double sistemaCirc_Retta[3] = {};//Verranno assegnati a questo vettore i coefficienti dell'equazione di secondo grado risultante dal sistema Circonferenza/Retta
double supportoCoordinate[2]{};//Verranno assegnati i valori di passaggio delle coordinate calcolate
short int i = 0;//Contatore
/*Elaborazione*/
//Acquisizione dei dati di input dell'equazione della circonferenza in un vettore interno alla funzione
for (i = 0; i < 5; i++)
supportoCirconferenza[i] = equazioneCirconferenza[i];
//Acquisizione dei dati di input dell'equazione della retta in un vettore interno alla funzione
for (i = 0; i < 3; i++)
supportoRetta[i] = equazioneRetta[i];
//Condizione che valuta l'inclinazione della retta e in base a questa decide come applicare il metodo di sostituzione tra le 2 equazioni
if (supportoRetta[1] != 0) {
sistemaCirc_Retta[2] = supportoCirconferenza[4] + pow(supportoRetta[2], 2);//incognita^2
sistemaCirc_Retta[1] = (2.0 * supportoRetta[2] * supportoRetta[0]) + supportoCirconferenza[2] + (supportoCirconferenza[1] * supportoRetta[2]);//Incognita
if ((supportoRetta[0] != 0) && (supportoRetta[2] != 0))
i = 0;
else
if (supportoRetta[0] == 0)
i = 0;
else
i = 1;
sistemaCirc_Retta[0] = pow(supportoRetta[i], 2) + (supportoCirconferenza[1] * supportoRetta[i]) + supportoCirconferenza[0];//Termine noto
}
else {
sistemaCirc_Retta[2] = supportoCirconferenza[3];//incognita^2
sistemaCirc_Retta[1] = supportoCirconferenza[1];//Incognita
sistemaCirc_Retta[0] = pow(supportoRetta[2], 2) + (supportoCirconferenza[2] * supportoRetta[2]) + supportoCirconferenza[0];//Termine noto
}
//Risoluzione dell'equazione di secondo grado ad una incognita
formulaEq_2(sistemaCirc_Retta, supportoCoordinate);
//Applico il metodo di sostituzione all'equazione della retta le coordinate appena calcolate
if (supportoRetta[1] != 0) {
coordinate[0] = supportoCoordinate[0];//Coordinata X1
coordinate[2] = supportoCoordinate[1];//Coordinata X2
if ((supportoRetta[0] != 0) && (supportoRetta[2] != 0)) {
coordinate[1] = (coordinate[0] * supportoRetta[2]) + supportoRetta[0];//Coordinata Y1
coordinate[3] = (coordinate[2] * supportoRetta[2]) + supportoRetta[0];//Coordinata Y2
}
else
if (supportoRetta[0] == 0) {
coordinate[1] = supportoRetta[2] * coordinate[0];//Coordinata Y1
coordinate[3] = supportoRetta[2] * coordinate[2];//Coordinata Y2
}
else {
coordinate[1] = supportoRetta[1];//Coordinata Y1
coordinate[3] = supportoRetta[1];//Coordinata Y2
}
}
else {
coordinate[0] = supportoRetta[2];//Coordinata X1
coordinate[1] = supportoCoordinate[0];//Coordinata Y1
coordinate[2] = supportoRetta[2];//Coordinata X2
coordinate[3] = supportoCoordinate[1];//Coordinata Y2
}
}
/*Calcola dall'equazione esplicita della retta (y=mx+q), il valore di coordinata richiesta, quindi ascissa o ordinata.*/
double estrazioneCoordinataEquazioneRetta(double* eqRetta, bool selezionaIncognitaDesiderata, double valoreIncognitaNota) {
if (eqRetta[2] == 0 && eqRetta[0] == 0)//Se angolo è a 0°
return eqRetta[1];//y
else if (eqRetta[1] == 0 && eqRetta[0] == 0)//Se angolo è 90°
return eqRetta[2];//x
else {
if (selezionaIncognitaDesiderata == false)
return (valoreIncognitaNota - eqRetta[0]) / eqRetta[2];//x=(y-q)/m
else
return (eqRetta[2] * valoreIncognitaNota) + eqRetta[0];//y=(m*x)+q
}
}
/*Funzione che restituisce in gradi compresi tra 0° e +/-360°, i valori superiori a 360° o inferiori a -360°.*/
double stabilizzaAngolo(double gradiAngolo) {
//Variabili locali
double segno = 1.0;
if (gradiAngolo < 0)
segno = -segno;
gradiAngolo = radianti(fabs(gradiAngolo));//Trasforma i gradi in radianti
gradiAngolo = cos(gradiAngolo);//Coseno dell'angolo
gradiAngolo = acos(gradiAngolo);//Arcocoseno dell'angolo
return (gradi(gradiAngolo) * segno);//Restituisce i gradi compresi tra 0° e 360°
}
//Analisi matematica
/*Funzione che restituisce in un vettore di 4 elementi l'equazione di un punto noto su circonferenza:
-Tpunto p = coordinate del punto noto della circonferenza;
-double* eq = equazione del punto su circonferenza del tipo xa + yb + c + tn = 0.
eq[0] = termine noto;
eq[1] = coefficiente di c;
eq[2] = coefficiente di b;
eq[3] = coefficiente di a;
eq[4] = coefficiente di b^2;
eq[5] = coefficiente di a^2.*/
void eqPuntoSuCirconf(Tpunto p, double* eq) {
eq[0] = pow(p.asc, 2) + pow(p.ord, 2);//tn
eq[1] = 1.0;//c
eq[2] = p.ord;//b
eq[3] = p.asc;//a
eq[4] = 0.0;//c^2
eq[5] = 0.0;//b^2
eq[6] = 0.0;//a^2
}
/*Funzione che restituisce l'equazione del raggio di una circonferenza.
double raggio = raggio della circonferenza;
double *eq = equazione del raggio su circonferenza del tipo: a^2 + b^2 -4c - (r^2 * 4) = 0.
eq[0] = termine noto;
eq[1] = coefficiente di c;
eq[2] = coefficiente di b;
eq[3] = coefficiente di a;
eq[4] = coefficiente di b^2;
eq[5] = coefficiente di a^2.*/
void eqRaggioCirconf(double raggio, double* eq) {
eq[1] = -4.0;//c
eq[0] = pow(raggio, 2) * eq[1];//tn
eq[2] = 0.0;//b
eq[3] = 0.0;//a
eq[4] = 0.0;//c^2
eq[5] = 1.0;//b^2
eq[6] = 1.0;//a^2
}
/*Funzione che restituisce i coefficienti fattorizzati dell'equazione di input. Questa cambia i valori dell'equazione inserita,
ma non modifica l'ordine degli elementi. A fine funzione la cella del fattore varrà zero.
short int lengthEquaz = lunghezza dell'array dell'equazione da fattorizzare (numero intero nominale);
short int numIndFat = numero effettivo dell'indirizzo array del fattore;
double* eq = equazione fattorizzata.*/
void fattorizzaEquazione(short int lengthEquaz, short int numIndFat, double* eq) {
//Variabili di lavoro locali
double fat = -eq[numIndFat];//Assegnazione del coefficiente fattorizzatore col segno invertito
//Elaborazione
for (short int i = 0; i < lengthEquaz; i++) {
eq[i] /= fat;//Fattorizzazione dell'equazione
if (fabs(eq[i]) <= 0.0001)
eq[i] = 0.0;
}
eq[numIndFat] = 0.0;//L'indirizzo dell'array che ha fatto da fattorizzatore dell'equazione assume il valore di uno
}
/*Funzione che restituisce il prodotto tra un numero (o coefficiente) ed un polinomio.
double coefficiente = numero che verrà moltiplicato per ogni singolo elemento del polinomio;
short int lengthPol = lunghezza del polinomio (numero intero nominale);
double* polinomio = vettore coi coefficienti del polinomio esaminato;
double* prodotto = vettore coi risultati del prodotto.*/
void prod_Coeff_Polinomio(double coefficiente, short int lengthPol, double* pol, double* prodotto) {
for (short int i = 0; i < lengthPol; i++) {
prodotto[i] = coefficiente * pol[i];
if (fabs(prodotto[i]) <= 0.0001)
prodotto[i] = 0.0;
}
}
/*Funzione che restituisce in un vettore di 3 elementi, il quadrato di un binomio del tipo: (x+1)^2.
double binomio[2] = vettore di input del binomio;
binomio[0] = termine noto;
binomio[1] = incognita;
double* quadratoBinomio = vettore di output, risultato del quadrato del binomio.
quadratoBinomio[0] = termine noto;
quadratoBinomio[1] = x;
quadratoBinomio[2] = x^2.*/
void sqrBinomio(double binomio[2], double* quadratoBinomio) {
quadratoBinomio[0] = pow(binomio[0], 2);//Termine noto
quadratoBinomio[1] = 2.0 * binomio[1] * binomio[0];//x
quadratoBinomio[2] = pow(binomio[1], 2);//x^2
}
/*Funzione che restituisce nell'array2 la somma degli elementi tra due vettori di ugual misura.
Il vettore array2 è quello che verrà cambiato dopo la funzione.
short int lengthArray = lunghezza effettiva di entrambi gli array;
double* array1 = vettore che contiene gli elementi del primo array;
double* array2 = vettore che contiene gli elementi del secondo array.*/
void sommaTraArrayOmogenei(short int lengthArray, double* array1, double* array2) {
for (short int i = 0; i < lengthArray; i++) {
array2[i] += array1[i];
if (fabs(array2[i]) <= 0.0001)
array2[i] = 0.0;
}
}
/*Funzione che compatta gli elementi di un array che sono diversi da zero, partendo dall'indirizzo indicato dall'utente fino a quello finale indicato,
gli elementi spostati sono sostituiti con zero. La lunghezza dll'array non viene modificata, ma gli elementi diversi da zero sono portati verso alle
prime celle dell'array.
-short int indicePartenza = numero che indica la cella iniziale dell'array da cui partire;
-short int numFinale = numero che indica la cella finale dell'array;
-double* array = array da esaminare.*/
void compattaArray(short int indicePartenza, short int numFinale, double* array) {
//Dichiarazione variabili locali
short int c = 0;//Contatore del ciclo annidato
short int j = indicePartenza;//Inizializzatore
double temp = 0.0;//Variabile di supporto temporanea
//Elaborazione
for (indicePartenza; indicePartenza < numFinale; indicePartenza++) {
for (c = j; c < numFinale; c++)
if (array[c] != 0.0) {
temp = array[c];
array[c] = 0.0;
c = numFinale - 1;
}
else
temp = 0.0;
if (temp != 0.0)
array[indicePartenza] = temp;
j++;
}
}
/*Funzione che ordina nell'array di output i valori di un array di input in base ad un passo indicato.
short int step = passo;
short int lengthArrayOutput = lunghezza nominale dell'array di output;
double* arrayInput = valori di input iniziali;
double* arrayOutput = valori ordinati dallo step.*/
void ordinaArrayPerStep(short int step, short int lengthArrayOutput, double* arrayInput, double* arrayOutput) {
//Dichiarazione variabili locali
short int c = 0;//Secondo contatore
//Elaborazione
for (short int i = 0; i < lengthArrayOutput; i++)
if ((i % step) == 0) {
arrayOutput[i] = arrayInput[c];//Assegnazione del valore
c++;//Incremento unario di c
}
else
arrayOutput[i] = 0.0;
}
/*Funzione che restituisce i centri circonferenze e le relative equazioni, aventi noti 2 punti ed il loro raggio.
-Tpunto* p: struttura avente le coordinate dei 2 punti noti delle circonferenze;
p[0].asc = ascissa di P1;
p[0].ord = ordinata di P1;
p[1].asc = ascissa di P2;
p[1].ord = ordinata di P2.
-Tcirconferenza* circonf1: struttura che contiene tutti i dati della circonferenza C1;
circonf1.centro.asc = ascissa centro di C1;
circonf1.centro.ord = ordinata centro di C1;
circonf1.raggio = raggio di C1 (e C2);
circonf1.eq[] = equazione di 5 elementi di secondo grado di C1.
-Tcirconferenza* circonf2: struttura che contiene tutti i dati della circonferenza C2;
circonf2.centro.asc = ascissa centro di C2;
circonf2.centro.ord = ordinata centro di C2;
circonf2.raggio = raggio di C2 (e C1);
circonf2.eq[] = equazione di 5 elementi di secondo grado di C2.*/
void centriCirPerDuePunti_Raggio(Tpunto* p, Tcirconferenza* circonf1, Tcirconferenza* circonf2) {
//Dichiarazione delle variabili locali
double A[7] = {};//Vettore equazione del punto A
double B[7] = {};//Vettore equazione del punto B
double R[7] = {};//Vettore equazione del raggio circonferenza
double supporto[7] = {};//Vettore di supporto per calcoli
bool actB = false;//Attiva la variabile B.b come fattorizzatore
double binomio[3] = {};//Binomio
short int j = 0;//Variabile di supporto
//Elaborazione
if (fabs(p[0].asc - p[1].asc) == (circonf1->raggio * 2.0) || fabs(p[0].ord - p[1].ord) == (circonf1->raggio * 2.0))
if (p[0].asc == p[1].asc) {
circonf1->centro.asc = p[0].asc;
circonf2->centro.asc = p[0].asc;
if (p[0].ord < p[1].ord) {
circonf1->centro.ord = p[0].ord + circonf1->raggio;
circonf2->centro.ord = circonf1->centro.ord;
}
else {
circonf1->centro.ord = p[0].ord - circonf1->raggio;
circonf2->centro.ord = circonf1->centro.ord;
}
}
else {
circonf1->centro.ord = p[0].ord;
circonf2->centro.ord = p[0].ord;
if (p[0].asc < p[1].asc) {
circonf1->centro.asc = p[0].asc + circonf1->raggio;
circonf2->centro.asc = circonf1->centro.asc;
}
else {
circonf1->centro.asc = p[0].asc - circonf1->raggio;
circonf2->centro.asc = circonf1->centro.asc;
}
}
else {
//Calcolo equazione del punto A e acquisizione nel vettore con cambio di segno
eqPuntoSuCirconf(p[0], A);
//Calcolo equazione del punto B
eqPuntoSuCirconf(p[1], B);
//Calcolo equazione del raggio circonferenza
eqRaggioCirconf(circonf1->raggio, R);
//Fattorizzazione dell'equazione punto A
fattorizzaEquazione(4, 1, A);//c = a + b + tn
//Sostituzione della variabile c nell'eq. di B
sommaTraArrayOmogenei(4, A, B);
B[1] = 0.0;//Azzeramento dell'incognita B.c
//Sostituzione della variabile c nell'eq. di R
prod_Coeff_Polinomio(R[1], 4, A, supporto);//Prodotto tra il coefficiente di c dell'eq. R e A
R[1] = 0.0;//Azzeramento dell'incognita R.c
sommaTraArrayOmogenei(7, supporto, R);//Somma tra i coefficienti simili di R
//Fattorizzazione dei termini dell'eq. B con B.a o B.b
if (B[3] == 0.0) {
actB = true;//Attiva la variabile B.b
j = 2;//Assume la posizione del fattorizzatore nell'equazione
}
else
j = 3;//Assume la posizione del fattorizzatore nell'equazione
fattorizzaEquazione(4, j, B);
if (actB == false) {
if (B[2] == 0.0)
B[3] = B[0];//L'incognita a è uguale al tn
j = 3;//Acquisizione numero cella coefficiente
R[6] = 0.0;//Azzeramento di a^2
}
else {
if (B[3] == 0.0)
B[2] = B[0];//L'incognita b è uguale al tn
j = 2;//Acquisizione numero cella coefficiente
R[5] = 0.0;//Azzeramento di b^2
}
B[0] = 0.0;//Azzeramento del tn di B
//Sostituzione dei termini dell'eq. B con quelli di A
azzeraVettore(7, supporto);//Azzeramento dell'array di supporto
prod_Coeff_Polinomio(A[j], 4, B, supporto);//Prodotto tra il coefficiente A.a o A.b con il polinomio di B
A[j] = 0.0;//Azzeramento della cella corrispondente al coefficiente del prodotto
sommaTraArrayOmogenei(7, supporto, A);//Somma tra i coefficienti simili di A
compattaArray(1, 4, A);//Compatta l'eq. A, il valore nella posizione A[1] non corrisponderà più all'incognita c, ma a b o a
//Sostituzione dei termini dell'eq. B con quelli di R
azzeraVettore(7, supporto);//Azzeramento dell'array di supporto
prod_Coeff_Polinomio(R[j], 4, B, supporto);//Prodotto tra il coefficiente A.a o A.b con il polinomio di B
R[j] = 0.0;//Azzeramento della cella corrispondente al coefficiente del prodotto
sommaTraArrayOmogenei(7, supporto, R);//Somma tra i coefficienti simili di R
compattaArray(1, 4, B);//Compatta l'eq. B, il valore nella posizione B[1] non corrisponderà più all'incognita c, ma a b o a
sqrBinomio(B, binomio);//Quadrato del binomio di B da passare a R
compattaArray(1, 7, R);//Compatta l'eq. di R
R[3] = 0.0;//Azzeramento ultima cella
sommaTraArrayOmogenei(3, binomio, R);//Somma tra i coefficienti simili di R con il quadrato del binomio
azzeraVettore(3, binomio);//Azzeramento del vettore
//Calcolo delle 2 soluzioni corrispondenti a b1 e b2 se actB è false, o a1 e a2 se actB true
formulaEq_2(R, binomio);
//Calcolo dei valori di a1 e a2 se actB è false, b1 e b2 se actB è true
B[2] = (B[1] * binomio[0]) + B[0];//B[2] assume il valore di a1\b1
B[3] = (B[1] * binomio[1]) + B[0];//B[3] assume il valore di a2\b2
//Il calcolo dei valori di c1 e c2 non fatti perchè le equazioni saranno calcolati poi con i due centri circonferenze più il raggio comune
//A[2] = (A[1] * binomio[0]) + A[0];//A[2] assume il valore di c1
//A[3] = (A[1] * binomio[1]) + A[0];//A[3] assume il valore di c2
//Calcolo delle coordinate dei centri delle circonferenze1 e circonferenza2
if (actB == false) {
circonf1->centro.asc = B[2] / (-2.0);//Ascissa di C1
circonf1->centro.ord = binomio[0] / (-2.0);//Ordinata di C1
circonf2->centro.asc = B[3] / (-2.0);//Ascissa di C2
circonf2->centro.ord = binomio[1] / (-2.0);//Ordinata di C2
}
else {
circonf1->centro.asc = binomio[0] / (-2.0);//Ascissa di C1
circonf1->centro.ord = B[2] / (-2.0);//Ordinata di C1
circonf2->centro.asc = binomio[1] / (-2.0);//Ascissa di C2
circonf2->centro.ord = B[3] / (-2.0);//Ordinata di C2
}
}
//Fine del calcolo del sistema
//Il vettore binomio assume i valori delle coordinate del centro circonferenza1 ed il raggio per essere passato alla funzione che calcola l'equazione
binomio[0] = circonf1->centro.asc;
binomio[1] = circonf1->centro.ord;
binomio[2] = circonf1->raggio;
//Il vettore supporto assume i valori delle coordinate del centro circonferenza2 ed il raggio per essere passato alla funzione che calcola l'equazione
supporto[0] = circonf2->centro.asc;
supporto[1] = circonf2->centro.ord;
supporto[2] = binomio[2];
//Calcolo dell'equazione della circonferenza1
circonferenza(binomio, circonf1->eq);
//Calcolo dell'equazione della circonferenza2
circonferenza(supporto, circonf2->eq);
}
int main() {
//Dichiarazione delle variabili di input
short int numeroLobi = 6;//Numero dei lati del poligono
double lobo[3] = { 1.025,0,0.34 };//Dati geometrici del lobo
double circonferenzaConcava[3] = { 2.350497,0,1.21 };//Dati geometrici della circonferenza concava
double dGrezzo = 2.75;//Diametro del grezzo
double coordSup = 0;//Coordinata di superficie in Z o inizio in Z della geometria
double zEnd = 1.5;//Indica la lunghezza in Z dalla coordinata di superficie (o più semplicemente è l'estrusione della geometria partendo dalla coordinata di superficie)
short int tool = 37;//Scelta del numero utensile
double rT = 1.0;//Raggio utensile
double asseC = 0;//Posizionamento dell'asse C
double passoZ = 0.06;//Indica il passo in Z che deve avere l'utensile
double gapSicurezza = 0.7;//Gap di sicurezza (ATTENZIONE: mettere un valore > al diametro utensile di 0.1mm)
double f = 250;//Avanzamento in lavorazione
int riduciFile = 100;//Riduce la dimensione del file d'uscita agendo sul feed (mettere 50 se si vuole dimezzare l'avanzamento in lavorazione)
bool salvataggio = true;//Consente di scegliere se salvare i dati su un file di testo o meno
//Dichiarazione delle variabili di lavoro
double gradiDalNumeroLobi = 0, zIncr = 0;
double supportoPunti[24] = {};
double eq_circonferenza1[5] = {}, eq_circonferenza2[5] = {};
double eq_retta[3] = {};
double punti[4] = {};
double puntiDiContattoUtensile[98] = {};//Vettore di output che può contenere le coordinate di 12 punti
short int limite = 0, a = 0, b = 0;
bool verificaRaggioCirconferenzaConcava = false;
FILE* torxMaschio = NULL;//Creazione del puntatore tipo FILE per salvataggio su file di testo
//Input
/* cout<<"\tPercorso utensile per torx femmina STRAUMANN";
cout<<endl<<"Numero lobi: ";
cin>>numeroLobi;
cout<<"Le ordinate delle circonferenze lobo e convessa sono sempre 0!";
cout<<endl<<"Distanza dall'origine del centro della circonferenza lobo: ";
cin>>lobo[0];
cout<<"Raggio della circonferenza lobo: ";
cin>>lobo[2];
cout<<"Distanza dall'origine del centro della circonferenza concava: ";
cin>>circonferenzaConcava[0];
cout<<"Raggio della circonferenza concava: ";
cin>>circonferenzaConcava[2];
cout<<"Diametro del grezzo: ";
cin>>dGrezzo;
cout<<"Coordinata di superficie: ";
cin>>coordSup;
cout<<"Profondita' della geometria torx: ";
cin>>zEnd;
cout<<"Numero utensile: ";
cin>>tool;
cout<<"Il diametro utensile non va messo qui, ma nei parametri\nutensile del PGM del DECO!"<<endl;
cout<<"Orientamento della geometria sull'asse C: ";
cin>>asseC;
cout<<"Passo in Z: ";
cin>>passoZ;
cout<<"Gap di sicurezza (ATTENZIONE: mettere un valore > al diametro utensile utilizzato di 0.1mm): ";
cin>>gapSicurezza;
cout<<"Ridurre la dimensione del file agendo sul feed della macchina\n(solo numeri interi)[%]: ";
cin>>riduciFile;
cout<<"Avanzamento in lavorazione (tenere conto della voce precedente)[mm/min]: ";
cin>>f;
cout<<"Salvare sul desktop in un file di testo? [NO=0; SI=1]: ";
cin>>salvataggio;*/
/*Elaborazione*/
//ATTENZIONE: impostare nel PGM della STAR #860 = #629
dGrezzo /= 2;//Raggio del preforo
dGrezzo += (rT + gapSicurezza);//Primo punto di attacco utensile in zona di sicurezza
//Primo punto di partenza dell'utensile
puntiDiContattoUtensile[0] = lobo[0] + lobo[2] + rT;//Ascissa
puntiDiContattoUtensile[1] = lobo[1];//Ordinata
//Calcolo del numero di punti che formano il percorso utensile
limite = numeroLobi * 2;
//Gradi e bisettrice dal numero lobi
gradiDalNumeroLobi = 360.0 / numeroLobi;//Gradi
gradiDalNumeroLobi /= 2.0;//Bisettrice
//Calcolo del punto di tangenza tra le circonferenze
//Compensazioni dei raggi utensile
circonferenzaConcava[2] -= rT;//Compensazione del raggio circonferenzaConcava in base al raggio utensile
lobo[2] += rT;//Compensazione del raggio lobo in base al raggio utensile
if (circonferenzaConcava[2] <= 0.0001 && circonferenzaConcava[2] >= -0.0001)
circonferenzaConcava[2] = 0;
if (circonferenzaConcava[2] <= 0)
//Polarizzazione delle coordinate del centro circonferenzaConcava
polarizzaPunto(false, circonferenzaConcava, gradiDalNumeroLobi, 1, punti);
else {
limite *= 2;//Doppio prodotto del numero dei punti che formano il percorso utensile
limite += 2;//Aggiunta delle coordinate dell'ultimo punto della geometria
verificaRaggioCirconferenzaConcava = true;//Cambio di stato; indica che l'utensile è più piccolo del raggio circonferenzaConcava
//Polarizzazione delle coordinate del centro circonferenzaConcava
polarizzaPunto(false, circonferenzaConcava, gradiDalNumeroLobi, 1, circonferenzaConcava);
//Calcolo delle equazione delle circonferenze: lobo e convessa
circonferenza(circonferenzaConcava, eq_circonferenza1);//Equazione circonferenza convessa
circonferenza(lobo, eq_circonferenza2);//Equazione circonferenza lobo
//Calcolo asse radicale
asseRadicaleTraCirconferenze(eq_circonferenza2, eq_circonferenza1, eq_retta);
//Sistema circonferenza convessa con asse radicale
sistemaCirconferenzaRetta(eq_circonferenza1, eq_retta, punti);
}
puntiDiContattoUtensile[2] = punti[0];//Il vettore della geometria acquisisce l'ascissa del punto P2
puntiDiContattoUtensile[3] = punti[1];//Il vettore della geometria acquisisce l'ordinata del punto P2
//Queste 2 celle con coordinate a zero, daranno il limite alla funzione che sarà chiamata dopo
puntiDiContattoUtensile[4] = 0;//Serve per dare il limite alla funzione successiva
puntiDiContattoUtensile[5] = 0;//Serve per dare il limite alla funzione successiva
//Settaggio dei parametri in base al raggio utensile
gradiDalNumeroLobi *= 2.0;//Ripristino dei gradi in base al numero dei lobi
creaGeometriaDaPunti(false, false, verificaRaggioCirconferenzaConcava, puntiDiContattoUtensile, numeroLobi - 1, gradiDalNumeroLobi, puntiDiContattoUtensile);
//Calcolo dei movimenti in Z e profondità d'estrusione della geometria torx
zIncr = coordSup;//Assegno come valore iniziale della Z incrementale la coordinata di superficie
zEnd += coordSup;//Calcolo della coordinata Z di arrivo dell'utensile
//Output
//Salvataggio dati sul desktop in un file di testo
if (salvataggio == true) {
//torxMaschio = fopen("C:\\Users\\ASUS\\Desktop\\Torx maschio.txt", "w");//Apertura del file .doc sul desktop
fopen_s(&torxMaschio, "C:\\Users\\User\\Desktop\\Torx maschio.txt", "w");//Apertura del file .doc sul desktop
if (torxMaschio == NULL) {
perror("Errore in apertura del file");
exit(1);
}
}
cout << endl;
cout << endl << "M105";//Disattiva la rotazione del mandrino principale
if (salvataggio == true)
fprintf(torxMaschio, "M105");//Salvataggio sul file
cout << endl << "M811";//Attiva rotazione del pneumatico
if (salvataggio == true)
fprintf(torxMaschio, "\nM811");//Salvataggio sul file
cout << endl << "G4 X2";//Sosta di 2 secondi
if (salvataggio == true)
fprintf(torxMaschio, "\nG4 X2");//Salvataggio sul file
cout << endl << "G1 X2=29 Y2=0 G100 T37";//Chiamata del numero utensile con relativo posizionamento rapido in zona XY di sicurezza
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 X2=29 Y2=0 G100 T37");//Salvataggio sul file
cout << endl << "G1 Z2=90 G100";//Posizionamento rapido in zona di sicurezza in Z
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 Z2=90 G100");//Salvataggio sul file
cout << endl << "M119 Q" << asseC;//Orientamento della geometria
if (salvataggio == true)
fprintf(torxMaschio, "\nM119 Q%.4lf", asseC);//Salvataggio sul file
cout << endl << "G902 P1=" << riduciFile;//Comando che riduce la dimensione del file d'uscita
if (salvataggio == true)
fprintf(torxMaschio, "\nG902 P1=%d", riduciFile);//Salvataggio sul file
cout << endl << "G1 Z2=" << coordSup + gapSicurezza << " G100";//Primo posizionamento dell'utensile in Z in zona di sicurezza
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 Z2=%.4lf G100", coordSup + gapSicurezza);//Salvataggio sul file
cout << endl << "G1 X2=" << (dGrezzo * 2.0) << " G100";//Posizionamento rapido in zona di sicurezza in X
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 X2=%.4lf G100", (dGrezzo * 2.0));//Salvataggio sul file
while (zIncr <= zEnd) {
zIncr += passoZ;//Incremento della Z in base al passo impostato dall'utente
//Condizione che limita la Z incrementale alla massima profondità
if (zIncr >= zEnd)
zIncr = zEnd;
cout << endl << endl << endl << "G1 Z2=-" << zIncr << " F5000 G94";//Posizionamento dell'utensile in Z
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 Z2=-%.4lf F5000 G94", zIncr);//Salvataggio sul file
for (a = 0; a <= limite; a += 2)
if (a == 0) {
cout << endl << "G1 X2=" << (puntiDiContattoUtensile[a] * 2.0) << " F" << f << " G94 G42";
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 X2=%.4lf F%.0f G94 G42", puntiDiContattoUtensile[a] * 2.0, f);//Salvataggio sul file
}
else
if ((a % 4 == 0) && (verificaRaggioCirconferenzaConcava == true)) {
b = 2;//Interpolazione circolare concava
cout << endl << "G" << b << " X2=" << (puntiDiContattoUtensile[a] * 2.0) << " Y2=" << puntiDiContattoUtensile[a + 1] << " R" << circonferenzaConcava[2];
if (salvataggio == true)
fprintf(torxMaschio, "\nG%d X2=%.4lf Y2=%.4lf R%.4lf", b, puntiDiContattoUtensile[a] * 2.0, puntiDiContattoUtensile[a + 1], circonferenzaConcava[2]);//Salvataggio sul file
}
else {
b = 3;//Interpolazione circolare convessa
if (a == limite) {
puntiDiContattoUtensile[a] = puntiDiContattoUtensile[0];//puntiDiContattoUtensile[2]
puntiDiContattoUtensile[a + 1] = puntiDiContattoUtensile[1];//puntiDiContattoUtensile[3]
}
cout << endl << "G" << b << " X2=" << (puntiDiContattoUtensile[a] * 2) << " Y2=" << puntiDiContattoUtensile[a + 1] << " R" << lobo[2];
if (salvataggio == true)
fprintf(torxMaschio, "\nG%d X2=%.4lf Y2=%.4lf R%.4lf", b, puntiDiContattoUtensile[a] * 2.0, puntiDiContattoUtensile[a + 1], lobo[2]);//Salvataggio sul file
}
cout << endl << "G1 Y2=" << puntiDiContattoUtensile[3];//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 Y2=%.4lf", puntiDiContattoUtensile[3]);//Salvataggio sul file
cout << endl << "G1 X2=" << dGrezzo * 2.0 << " F5000 G94";//Posizionamento rapido in X dell'utensile in zona di sicurezza
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 X2=%.4lf F5000 G94", (dGrezzo * 2.0));//Salvataggio sul file
cout << endl << "G40";//Annullamento compensazione automatica
if (salvataggio == true)
fprintf(torxMaschio, "\nG40");//Salvataggio sul file
cout << endl << "G1 Y2=0 G100";//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 Y2=0 G100");//Salvataggio sul file
//Condizione che interrompe il ciclo ed esce
if (zIncr == zEnd)
break;
}
cout << endl << "G902";//Disattiva il codice G902 iniziale
if (salvataggio == true)
fprintf(torxMaschio, "\nG902");//Salvataggio sul file
/* cout<<endl<<"G1 Y2=0 G100";//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
if(salvataggio == true)
fprintf(torxMaschio,"\nG1 Y2=0 G100");//Salvataggio sul file
cout<<endl<<"G1 X2=29 G100";//Svincolo dell'utensile in Z
if(salvataggio == true)
fprintf(torxMaschio,"\nG1 X2=29 G100");//Salvataggio sul file*/
cout << endl << "G1 Z2=90 G100";//Svincolo dell'utensile in Z
if (salvataggio == true)
fprintf(torxMaschio, "\nG1 Z2=90 G100");//Salvataggio sul file
cout << endl << "M812";//Disattiva la rotazione del pneumatico
if (salvataggio == true)
fprintf(torxMaschio, "\nM812");//Salvataggio sul file
if (salvataggio == true) {
fclose(torxMaschio);//Chiusura del file di testo di salvataggio
cout << endl << endl << endl << "File di testo salvato sul desktop...";
}
fflush(stdin);
getchar();
return 0;
}