internal static void GetFaceRoughing(PathGenerator.MoveActionCollection moveCollection, double diametroMax, double diametroMin, double zMin, double zMax, double profPassata, double stacco)
{
if (CheckValueHelper.GreatherThanZero(new[] { profPassata }))
{
return;
}
var dMax = diametroMax;
var dMin = diametroMin;
var zEnd = zMin;
var currentZ = zMax;
while (currentZ > zEnd)
{
currentZ -= profPassata;
if (currentZ <= zEnd)
{
currentZ = zEnd;
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currentZ, dMax, 0);
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xyz, null, dMin, 0);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currentZ + stacco, dMax, 0);
}
}
//internal override ProgramPhase GetOperationProgram(Operazione operazione)
//{
// /*
// * il richiamo degli utensili magari farlo e delle operazioni comuni magari farlo in astratto più a monte
// *
// */
// /*
// *
// * su spianatura tradizionale se rimane ultima passata piccola lo togle con il centro della fresa.
// */
// var program = new ProgramPhase(SicurezzaZ);
// // cambio utensile // se
// var toolChange = new ChangeToolAction(program, operazione);
// program.ActiveAsseC(true);
// var parametro = operazione.GetParametro<ParametroFresaSpianare>();
// if (parametro == null)
// throw new NullReferenceException();
// var larghezzaPassata = parametro.GetLarghezzaPassata();
// var profPassata = parametro.GetProfonditaPassata();
// var diaFresa = parametro.DiametroMinimoFresa;
// diaFresa -= parametro.GetRaggioInserto() * 2;
// var diaIngombroFresa = parametro.DiametroIngombroFresa;
// var secureFeed = 1;
// var extraCorsa = 1;
// var feed = parametro.GetFeed(FeedType.ASync);
// var sovraMetallo = Sovrametallo - SovrametalloPerFinitura;
// var ottimizza = false; // per ora non lo lascio modificare da utente
// var passataMinimaPercentuale = 20.0d; // -- ,, valori sballati potrebbero causare bug non previsti
// if (feed <= 0)
// return null;
// var feedDictionary = new Dictionary<MoveType, double>
// {
// {MoveType.Rapid, 10000},
// {MoveType.SecureRapidFeed, secureFeed},
// {MoveType.Work, feed},
// {MoveType.Cw, feed},
// {MoveType.Ccw, feed},
// {MoveType.PlungeFeed, feed /2}
// };
// program.SetFeedDictionary(feedDictionary);
// var moveCollection = new MoveActionCollection();
// var centerPoint = GetCenterPoint();
// switch ((LavorazioniEnumOperazioni)operazione.OperationType)
// {
// case LavorazioniEnumOperazioni.FresaturaSpianaturaSgrossatura:
// {
// var zLavoro = LivelloZ + SovrametalloPerFinitura;
// switch (ModoSgrossatura)
// {
// case SpiantaturaMetodologia.Tradizionale:
// {
// OneDirectionFaceMilling(moveCollection, centerPoint.X, centerPoint.Y, Larghezza, Altezza, larghezzaPassata, diaFresa, diaIngombroFresa, sovraMetallo, profPassata, zLavoro, SicurezzaZ, extraCorsa);
// } break;
// case SpiantaturaMetodologia.Spirale:
// {
// SpiralFaceMillingV2(moveCollection, centerPoint.X, centerPoint.Y, Larghezza, Altezza, larghezzaPassata, diaFresa, diaIngombroFresa, sovraMetallo, profPassata, zLavoro, SicurezzaZ, extraCorsa, ottimizza, passataMinimaPercentuale);
// } break;
// }
// } break;
// case LavorazioniEnumOperazioni.FresaturaSpianaturaFinitura:
// {
// switch (ModoFinitura)
// {
// case SpiantaturaMetodologia.Tradizionale:
// {
// OneDirectionFaceMilling(moveCollection,
// centerPoint.X, centerPoint.Y,
// Larghezza, Altezza, larghezzaPassata,
// diaFresa,
// diaIngombroFresa,
// SovrametalloPerFinitura,
// profPassata,
// LivelloZ,
// SicurezzaZ,
// extraCorsa
// );
// } break;
// case SpiantaturaMetodologia.Spirale:
// {
// // richiamo stesso procedimento , metto solo profondita == sovrametallo
// // magari fare spiarale singolo in un metodo e richiamarla con sgrossatura più volte
// SpiralFaceMillingV2(moveCollection,
// centerPoint.X, centerPoint.Y,
// Larghezza, Altezza,
// larghezzaPassata,
// diaFresa,
// diaIngombroFresa,
// SovrametalloPerFinitura,
// profPassata,
// LivelloZ, SicurezzaZ, extraCorsa,
// ottimizza,
// passataMinimaPercentuale);
// } break;
// }
// } break;
// }
// var mm = base.GetFinalProgram(moveCollection);
// foreach (var variable in mm)
// {
// program.AddMoveAction(variable);
// }
// program.ActiveAsseC(false);
// return program;
//}
private static void OneDirectionFaceMilling(MoveActionCollection programPhase,
double offsetX, double offsetY,
double larghezza, double altezza,
double larghPassata, double diaFresa, double diaIngombroFresa,
double sovraMetallo, double profPassata,
double zFinale, double zSicurezza,
double extraCorsaSicurezza)
{
if (CheckValueHelper.GreatherOrEqualZero(new[] { sovraMetallo, extraCorsaSicurezza }) ||
CheckValueHelper.GreatherThanZero(new[] { larghezza, altezza, larghPassata, diaFresa, diaIngombroFresa, profPassata, }) ||
CheckValueHelper.GreatherThan(new[]
{
new KeyValuePair <double, double>(zSicurezza, zFinale + sovraMetallo),
new KeyValuePair <double, double>(diaFresa, larghPassata),
})
)
{
return;
}
var zCurrent = zFinale + sovraMetallo;
var xIni = offsetX - larghezza / 2;
var xFin = offsetX + larghezza / 2;
var yIni = offsetY + altezza / 2 + diaFresa / 2;
var yFin = offsetY - altezza / 2;
xIni -= (diaIngombroFresa / 2) + extraCorsaSicurezza;
xFin += (diaIngombroFresa / 2) + extraCorsaSicurezza;
// Itero per tutte le passate in Z
while (zCurrent > zFinale)
{
zCurrent -= profPassata;
if (zCurrent < zFinale)
{
zCurrent = zFinale;
}
{
OneDirectionHorizontal(programPhase, zCurrent, zSicurezza, xIni, xFin, yIni, yFin, larghPassata);
}
}
/*
* Pensare a come riutilizzarla per direzione orizzontale e verticale
*/
}
/*
* mi serve
* 1- metodo che mi restituisca i profili calcolati
*
*
*
*/
//private static List<Profile2D> CalculateInternOffset(Profile2D origin, double offsetValue, double diameterValue)
//{
// offsetValue = -Math.Abs(offsetValue);
// var firstPaths = origin.Offset(-diameterValue, false);
// if (firstPaths == null)
// return null;
// var rslt = new List<Profile2D>();
// foreach (var firstPath in firstPaths)
// {
// rslt.Add(firstPath);
// RicorsivaGenerateInternOffset(firstPath, offsetValue, false, ref rslt);
// }
// return rslt;
//}
//private static void RicorsivaGenerateInternOffset(Profile2D profile2D, double offset, bool clockwise, ref List<Profile2D> profile2DsList)
//{
// // Calcola offset , ritorna 1 o più contorni
// var offsetRslt = profile2D.Offset(offset, clockwise);
// // se non ritorna più niente termina metodo
// if (offsetRslt == null)
// return;
// foreach (var singleContour in offsetRslt)
// {
// profile2DsList.Add(singleContour);
// RicorsivaGenerateInternOffset(singleContour, offset, clockwise, ref profile2DsList);
// }
//}
private static void FresaturaSmussaturaScanalaturaChiusaProgram(MoveActionCollection moveActionCollection, Profile2D profile2D, double profonditaSmusso, double zSicurezza, double zIniziale, double diaFresa, double larghezzaScanaltura)
{
/*
* teoria.
* - Prendo profilo
* - Se valido faccio offset negativo del raggio della fresa
* - Poi faccio offset della larghezza di passata fino a che il metodo non mi restituisce più niente. ( ho raggiunto il massimo )
*/
/*
* Controllo Valori
*/
if (CheckValueHelper.GreatherThanZero(new[] { profonditaSmusso, diaFresa, larghezzaScanaltura }) ||
CheckValueHelper.GreatherThan(new[]
{
new KeyValuePair <double, double>(zSicurezza, zIniziale),
})
)
{
return;
}
if (profile2D == null)
{
return;
}
/*
* chiamo metodo comune per 2 profili (maggiore e minore della fresatura di scanalatura)
*/
var offsetValue = larghezzaScanaltura / 2;
var profileExt = profile2D.Offset(offsetValue, true);
var profileInt = profile2D.Offset(-offsetValue, true);
if ((profileExt == null || profileExt.Count == 0) ||
(profileInt == null || profileInt.Count == 0))
{
return;
}
MillProgrammingHelper.GetExterChamfer(moveActionCollection, profileInt[0], null, false, profonditaSmusso, diaFresa, 0, false, zIniziale, zSicurezza);
MillProgrammingHelper.GetInternChamfer(moveActionCollection, profileExt[0], profonditaSmusso, diaFresa, 0, false, zIniziale, zSicurezza);
}
internal static void GetRoughingTurnProgram(ProgramOperation programOperation, MoveActionCollection moveCollection, Profile2D profile2D, double profPassata, double avvicinamento, double stacco, Tornitura.TipoTornitura tipoTornitura, bool useMacro, double sovraX, double sovraZ)
{
// assumo che sia diametro esterno.
if (CheckValueHelper.GreatherThanZero(new[] { profPassata, }))
{
return;
}
if (profile2D == null)
{
return;
}
if (useMacro)
{
var turnMacro = new MacroLongitudinalTurningAction(programOperation)
{
SovraMetalloX = sovraX,
SovraMetalloZ = sovraZ,
Profile = profile2D,
ProfonditaPassata = profPassata,
Distacco = stacco,
TipologiaLavorazione = tipoTornitura,
};
}
switch (tipoTornitura)
{
case Tornitura.TipoTornitura.Esterna:
{
GetSgrossaturaEsterna(programOperation, moveCollection, profile2D, profPassata, avvicinamento, stacco);
} break;
case Tornitura.TipoTornitura.Interna:
{
GetSgrossaturaInterna(moveCollection, profile2D, profPassata, avvicinamento, stacco, useMacro);
} break;
}
}
internal static void GetSgrossaturaGolaFrontale(PathGenerator.MoveActionCollection moveCollection, double diameterIniziale, double diameterFinale, double iniZ, double endZ, double step, double larghPassata, double rit)
{
if (CheckValueHelper.GreatherThanZero(new[] { larghPassata }))
{
return;
}
var effectiveEndX = diameterFinale;
/*
* assumo di partire da sx e andare verso dx
*/
var currentX = diameterIniziale;
if (step <= 0)
{
step = iniZ - endZ;
}
var currenzZ = iniZ;
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currenzZ, currentX, 0);
while (currenzZ > endZ)
{
currenzZ -= Math.Abs(step);
if (currenzZ < endZ)
{
currenzZ = endZ;
}
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xyz, currenzZ, null, 0);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currenzZ + rit, null, 0);
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, iniZ, null, 0);
while (currentX < effectiveEndX)
{
currentX += larghPassata;
if (currentX > effectiveEndX)
{
currentX = effectiveEndX;
}
currenzZ = iniZ;
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, null, currentX, 0);
while (currenzZ > endZ)
{
currenzZ -= Math.Abs(step);
if (currenzZ < endZ)
{
currenzZ = endZ;
}
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xyz, currenzZ, null, 0);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currenzZ + rit, null, 0);
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, iniZ, null, 0);
}
}
internal static void GetSgrossaturaGolaInterna(PathGenerator.MoveActionCollection moveCollection, double diameterIniziale, double diameterFinale, double effectiveStart, double endZ, double step, double larghPassata, double rit)
{
if (CheckValueHelper.GreatherThanZero(new[] { diameterFinale, diameterIniziale, larghPassata }))
{
return;
}
var s = effectiveStart;
var e = endZ;
/*
* assumo di partire da sx e andare verso dx
*/
var currentZ = effectiveStart;
if (step <= 0)
{
step = diameterFinale - diameterIniziale;
}
var currentD = diameterIniziale;
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currentZ, currentD, 0);
while (currentD < diameterFinale)
{
currentD += step;
if (currentD > diameterFinale)
{
currentD = diameterFinale;
}
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xyz, currentZ, currentD, 0);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currentZ, currentD - rit, 0);
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, null, diameterIniziale, 0);
while (currentZ < e)
{
currentZ += larghPassata;
if (currentZ > e)
{
currentZ = e;
}
currentD = diameterIniziale;
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currentZ, currentD, 0);
while (currentD < diameterFinale)
{
currentD += step;
if (currentD > diameterFinale)
{
currentD = diameterFinale;
}
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xyz, currentZ, currentD, 0);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currentZ, currentD - rit, 0);
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, currentZ, diameterIniziale, 0);
}
}
/// <summary>
/// Calcola percorso di spianatura a spirale
/// </summary>
/// <param name="programPhase"></param>
/// <param name="offsetX"></param>
/// <param name="offsetY"></param>
/// <param name="larghezza"></param>
/// <param name="altezza"></param>
/// <param name="larghPassata"></param>
/// <param name="diaFresaEffettivo">Diametro Effettivo Fresa</param>
/// <param name="diaFresaIngombro">Diametro Ingombro Fressa</param>
/// <param name="sovraMetallo"></param>
/// <param name="profPassata"></param>
/// <param name="zFinale"></param>
/// <param name="zSicurezza">Z Sicurezza</param>
/// <param name="extraCorsaSicurezza"></param>
/// <param name="ottimizzaPassate">Con true calcolo nuova larghezza di passata minima</param>
/// <param name="passataMinimaPercentuale">Passata Minima Percentuale</param>
private static void SpiralFaceMillingV2(MoveActionCollection programPhase,
double offsetX, double offsetY,
double larghezza, double altezza,
double larghPassata, double diaFresaEffettivo,
double diaFresaIngombro,
double sovraMetallo, double profPassata,
double zFinale, double zSicurezza,
double extraCorsaSicurezza, bool ottimizzaPassate, double passataMinimaPercentuale)
{
/*
* todo : considerare anche raggio inserto--
*/
/*
* é meglio se avanzamenti li registro qui..
*/
if (CheckValueHelper.GreatherOrEqualZero(new[] { sovraMetallo, extraCorsaSicurezza }) ||
CheckValueHelper.GreatherThanZero(new[] { larghezza, altezza, larghPassata, diaFresaEffettivo, profPassata, diaFresaIngombro }) ||
CheckValueHelper.GreatherThan(new[]
{
new KeyValuePair <double, double>(zSicurezza, zFinale + sovraMetallo),
new KeyValuePair <double, double>(diaFresaEffettivo, larghPassata),
})
)
{
return;
}
/*
* Per creare spianatura divido l'area di lavoro in griglia a quadrati con lato == larghezzaPassata
*/
var larghezzaPassataX = larghPassata;
var larghezzaPassataY = larghPassata;
var nColonneTeoriche = larghezza / larghPassata;
var nRigheTeoriche = altezza / larghPassata;
var nColonne = (int)Math.Floor(nColonneTeoriche);
var nRighe = (int)Math.Floor(nRigheTeoriche);
/*
* devo per forza cambiare larghPassata, mantenendo il valore compreso fra un min e max.
*
* una volta che ho questo valore , proseguo per il mio ciclo come solito..
*
*/
if (ottimizzaPassate)
{
var passataMin = (larghPassata * passataMinimaPercentuale) / 100;
var restoX = larghezza % larghezzaPassataX;
var restoY = altezza % larghezzaPassataY;
if (restoX < passataMin)
{
// modifico larghezza passata X
larghezzaPassataX = larghezza / nColonne;
nColonne--;
}
if (restoY < passataMin)
{
// modifico larghezza passata Y
larghezzaPassataY = altezza / nRighe;
// dimuisco numero di righe,
nRighe--;
}
}
/*
* Raggio della fresa, sara il raggio che usero durante gli angoli nella spianatura
*/
var raggioEffettivoFresa = diaFresaEffettivo / 2;
/*
* todo: gestire anche diversi direzioni lavorazione e quindi punti entrata
*/
var sx = offsetX - larghezza / 2;
var dx = offsetX + larghezza / 2;
var down = offsetY - altezza / 2;
var up = offsetY + altezza / 2;
/*
* in pratica per trovare punto arrivo moltiplico la larghezza di Passata per le celle delle griglia rimaste..
*/
var zCurrent = zFinale + sovraMetallo;
// Itero per tutte le passate in Z
while (zCurrent > zFinale)
{
zCurrent -= profPassata;
if (zCurrent < zFinale)
{
zCurrent = zFinale;
}
// rimuovere
var minElement = (int)Math.Min(nColonne, nRighe);
/*
* 1.1 ) Punto attacco XY
*
* Il punto di inizio in alto a dx , tiene presente dell'ingombro massimo fresa e diametro effettivo di lavorazione + extraCorsaSicurezza
*/
var raggioIngombro = diaFresaIngombro / 2;
var puntoInizio = new Point2D
{
X = sx + (nColonne) * larghezzaPassataX,
Y = up + raggioIngombro + extraCorsaSicurezza
};
programPhase.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, puntoInizio.X, puntoInizio.Y, null);
programPhase.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, zSicurezza);
// 1.2 ) Andare a z Corrent
programPhase.AddLinearMove(MoveType.SecureRapidFeed, AxisAbilited.Z, null, null, zCurrent);
// 1.3 ) Punto avvicinamento diametro effettivo fresa
var puntoAvvi = new Point2D
{
X = puntoInizio.X,
Y = up + raggioEffettivoFresa
};
programPhase.AddLinearMove(MoveType.PlungeFeed, AxisAbilited.Xy, puntoAvvi.X, puntoAvvi.Y, null);
// 1.4) Interpolazione per fare entrata
var puntoFinaleArcoEntrata = new Point2D
{
X = sx + (nColonne * larghezzaPassataX) + raggioEffettivoFresa,
Y = up,
};
programPhase.AddArcMove(AxisAbilited.Xy, puntoFinaleArcoEntrata.X, puntoFinaleArcoEntrata.Y, null, raggioEffettivoFresa, true, new Point2D(puntoAvvi.X, up));
/*
* Ora magari vorrei cercare di cambiare ciclo in qualcosa di più chiaro e gestibile..
*
* qui a posso usare metodi aux..
*
* poso
*/
// 1.5) Lavorazione fino a termine materiale
var continueCycle = true;
var moveEnum = SpiralMoveEnum.ToDown;
var startMove = moveEnum;
var tempX = puntoFinaleArcoEntrata.X;
var tempY = puntoFinaleArcoEntrata.Y;
// cambiare se cambia senso direzione
// counterCelleY++;
var tempConterColonne = nColonne;
var tempCounterRighe = nRighe;
while (continueCycle)
{
continueCycle = SpiralMovementV2(programPhase, ref moveEnum, ref tempX, ref tempY, up, down, sx, dx, larghezzaPassataX, larghezzaPassataY, ref tempConterColonne, ref tempCounterRighe, nRighe, nColonne, minElement, raggioEffettivoFresa);
// anche questo va cambiato se si decide di fare scegliere punto attacco
//if (moveEnum == SpiralMoveEnum.ToDown)
//{
// tempConterColonne--;
// tempCounterRighe--;
//}
}
// 1.6) Porto fresa a Z Sicurezza
programPhase.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, zSicurezza);
}
}
//internal override ProgramPhase GetOperationProgram(Operazione operazione)
//{
// /*
// * il richiamo degli utensili magari farlo e delle operazioni comuni magari farlo in astratto più a monte
// *
// */
// var program = new ProgramPhase(SicurezzaZ);
// // cambio utensile // se
// var toolChange = new ChangeToolAction(program, operazione);
// /*
// * potrei settare qui punto iniziale.. non vedo altre opzioni. rimane sempre una cosa da ricordarsi in più
// * >> more bugs..
// */
// program.ActiveAsseC(true);
// var secureFeed = 1;
// var extraCorsa = 1;
// var parametro = operazione.GetParametro<ParametroFresaCandela>();
// var feed = parametro.GetFeed(FeedType.ASync);
// if (feed <= 0)
// return null;
// var feedDictionary = new Dictionary<MoveType, double>
// {
// {MoveType.Rapid, 10000},
// {MoveType.SecureRapidFeed, secureFeed},
// {MoveType.Work, feed},
// {MoveType.Cw, feed},
// {MoveType.Ccw, feed},
// };
// program.SetFeedDictionary(feedDictionary);
// if (parametro == null)
// throw new NullReferenceException();
// var moveCollection = new MoveActionCollection();
// switch ((LavorazioniEnumOperazioni)operazione.OperationType)
// {
// case LavorazioniEnumOperazioni.Sgrossatura:
// {
// var par = operazione.GetParametro<ParametroFresaCandela>();
// if (par == null)
// throw new NullReferenceException();
// var profPassat = par.GetProfonditaPassata();
// var larghPassat = par.GetLarghezzaPassata();
// ProcessRoughLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, Sovrametallo, ProfonditaLavorazione,
// profPassat, larghPassat, par.DiametroFresa, SicurezzaZ, extraCorsa, InizioLavorazioneZ);
// } break;
// case LavorazioniEnumOperazioni.Finitura:
// {
// var par = operazione.GetParametro<ParametroFresaCandela>();
// if (par == null)
// throw new NullReferenceException();
// var profPassat = par.GetProfonditaPassata();
// var larghPassat = par.GetLarghezzaPassata();
// /*
// * Per finitura assumo sovrametallo minore della larghezza passata
// */
// ProcessRoughLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, larghPassat, ProfonditaLavorazione,
// profPassat, larghPassat, par.DiametroFresa, SicurezzaZ, extraCorsa, InizioLavorazioneZ);
// } break;
// case LavorazioniEnumOperazioni.Smussatura:
// {
// var par = operazione.GetParametro<ParametroFresaCandela>();
// if (par == null)
// throw new NullReferenceException();
// /*
// * qui al posto della profondita lavorazione uso valore profondita fresa smussatura.
// */
// ProcessChamferSideLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, Sovrametallo, ProfonditaFresaSmussatura, par.DiametroFresa, SicurezzaZ, extraCorsa, InizioLavorazioneZ);
// } break;
// default:
// throw new NotImplementedException();
// }
// var mm = base.GetFinalProgram(moveCollection);
// foreach (var variable in mm)
// {
// program.AddMoveAction(variable);
// }
// program.ActiveAsseC(false);
// return program;
//}
private static void ProcessRoughLineMilling(MoveActionCollection moveCollection, double puntoInizialeX, double puntoInizialeY, double orientationAngle,
double lunghezza, double sovrametallo, double profonditaLavorazione, double profPassat, double larghPassat,
double diaFresa, double sicurezzaZ, double extraCorsa, double inizioLavorazioneZ, int isCncCompensated = 0)
{
if (CheckValueHelper.GreatherThanZero(new[] { profPassat, larghPassat, lunghezza, sovrametallo, profonditaLavorazione, diaFresa }) ||
CheckValueHelper.GreatherThan(new[]
{
new KeyValuePair <double, double>(sicurezzaZ, inizioLavorazioneZ),
})
)
{
return;
}
var currentZ = inizioLavorazioneZ;
var zFinale = currentZ - profonditaLavorazione;
var raggioFresa = diaFresa / 2;
var offset = raggioFresa;
if (isCncCompensated != 0)
{
offset = 0;
}
var xIniPoint = puntoInizialeX - extraCorsa - raggioFresa;
var xEndPoint = puntoInizialeX + extraCorsa + raggioFresa + lunghezza;
var yIniPoint = puntoInizialeY + sovrametallo + offset;
var yEndPoint = puntoInizialeY + offset;
CncCompensationState cncCompensationState = CncCompensationState.NoChange;
if (isCncCompensated == 1)
{
cncCompensationState = CncCompensationState.G41;
}
else if (isCncCompensated == 2)
{
cncCompensationState = CncCompensationState.G42;
}
var rotationMatrix = new Matrix3D();
rotationMatrix.RotateAt(new Quaternion(new Vector3D(0, 0, 1), orientationAngle), new System.Windows.Media.Media3D.Point3D(puntoInizialeX, puntoInizialeY, 0));
while (currentZ > zFinale)
{
currentZ -= profPassat;
if (currentZ < zFinale)
{
currentZ = zFinale;
}
var currentY = yIniPoint;
while (currentY > yEndPoint)
{
currentY -= larghPassat;
if (currentY < yEndPoint)
{
currentY = yEndPoint;
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, xIniPoint, currentY, null, rotationMatrix, null, cncCompensationState);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, sicurezzaZ);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, currentZ);
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xy, xEndPoint, currentY, null, rotationMatrix);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, sicurezzaZ);
}
if (cncCompensationState == CncCompensationState.G41 || cncCompensationState == CncCompensationState.G42)
{
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, sicurezzaZ, null, CncCompensationState.G40);
}
}
}
